Changeset f57dd25


Ignore:
Timestamp:
May 29, 2019, 3:45:00 PM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
0aedb01
Parents:
157a816 (diff), ebc0a85 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'cleanup-dtors'

Files:
4 added
46 edited

Legend:

Unmodified
Added
Removed
  • libcfa/prelude/Makefile.am

    r157a816 rf57dd25  
    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
     57        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
    5858        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    5959
  • libcfa/prelude/Makefile.in

    r157a816 rf57dd25  
    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
     558        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
    559559        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    560560
  • libcfa/prelude/builtins.c

    r157a816 rf57dd25  
    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
     18forall(dtype T)
     19struct __Destructor {
     20        T * object;
     21        void (*dtor)(T *);
     22};
     23
     24// defined destructor in the case that non-generated code wants to use __Destructor
     25forall(dtype T)
     26static 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
     33extern "C" {
     34        forall(dtype T)
     35        static inline void __destroy_Destructor(__Destructor(T) * dtor) {
     36                ^(*dtor){};
     37        }
     38}
    1539
    1640// exception implementation
  • src/AST/Convert.cpp

    r157a816 rf57dd25  
    884884                );
    885885
    886                 rslt->tempDecls = get<ObjectDecl>().acceptL(node->tempDecls);
    887                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
    888                 rslt->dtors = get<Expression>().acceptL(node->dtors);
    889 
    890886                auto expr = visitBaseExpr( node, rslt );
    891887                this->node = expr;
     
    22822278                );
    22832279
    2284                 rslt->tempDecls = GET_ACCEPT_V(tempDecls, ObjectDecl);
    2285                 rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
    2286                 rslt->dtors = GET_ACCEPT_V(dtors, Expr);
    2287 
    22882280                this->node = visitBaseExpr( old, rslt );
    22892281        }
  • src/AST/Expr.hpp

    r157a816 rf57dd25  
    530530public:
    531531        ptr<ApplicationExpr> callExpr;
    532         std::vector<ptr<ObjectDecl>> tempDecls;
    533         std::vector<ptr<ObjectDecl>> returnDecls;
    534         std::vector<ptr<Expr>> dtors;
    535532
    536533        ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
    537         : Expr( loc, call->result ), tempDecls(), returnDecls(), dtors() { assert( call ); }
     534        : Expr( loc, call->result ) { assert( call ); }
    538535
    539536        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
  • src/AST/Pass.impl.hpp

    r157a816 rf57dd25  
    13191319                }
    13201320                maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
    1321                 maybe_accept( node, &ImplicitCopyCtorExpr::tempDecls   );
    1322                 maybe_accept( node, &ImplicitCopyCtorExpr::returnDecls );
    1323                 maybe_accept( node, &ImplicitCopyCtorExpr::dtors       );
    13241321        )
    13251322
  • src/AST/Print.cpp

    r157a816 rf57dd25  
    10231023                os << "Implicit Copy Constructor Expression:" << endl << indent;
    10241024                safe_print( node->callExpr );
    1025                 os << endl << indent-1 << "... with temporaries:" << endl;
    1026                 printAll( node->tempDecls );
    1027                 os << endl << indent-1 << "... with return temporaries:" << endl;
    1028                 printAll( node->returnDecls );
    10291025                --indent;
    10301026                postprint( node );
  • src/Common/PassVisitor.impl.h

    r157a816 rf57dd25  
    17891789        VISIT_START( node );
    17901790
    1791         indexerScopedAccept( node->result     , *this );
    1792         maybeAccept_impl   ( node->callExpr   , *this );
    1793         maybeAccept_impl   ( node->tempDecls  , *this );
    1794         maybeAccept_impl   ( node->returnDecls, *this );
    1795         maybeAccept_impl   ( node->dtors      , *this );
     1791        indexerScopedAccept( node->result    , *this );
     1792        maybeAccept_impl   ( node->callExpr  , *this );
    17961793
    17971794        VISIT_END( node );
     
    18021799        MUTATE_START( node );
    18031800
    1804         indexerScopedMutate( node->env        , *this );
    1805         indexerScopedMutate( node->result     , *this );
    1806         maybeMutate_impl   ( node->callExpr   , *this );
    1807         maybeMutate_impl   ( node->tempDecls  , *this );
    1808         maybeMutate_impl   ( node->returnDecls, *this );
    1809         maybeMutate_impl   ( node->dtors      , *this );
     1801        indexerScopedMutate( node->env       , *this );
     1802        indexerScopedMutate( node->result    , *this );
     1803        maybeMutate_impl   ( node->callExpr  , *this );
    18101804
    18111805        MUTATE_END( Expression, node );
  • src/ControlStruct/ExceptTranslate.cc

    r157a816 rf57dd25  
    319319                        }
    320320
    321                         block->push_back( handler->get_body() );
    322                         handler->set_body( nullptr );
     321                        block->push_back( handler->body );
     322                        handler->body = nullptr;
    323323
    324324                        std::list<Statement *> caseBody
  • src/GenPoly/Box.cc

    r157a816 rf57dd25  
    657657                                paramExpr = new AddressExpr( paramExpr );
    658658                        } // if
    659                         arg = appExpr->get_args().insert( arg, paramExpr ); // add argument to function call
     659                        arg = appExpr->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->set_env( appExpr->get_env() );
    664                         appExpr->set_env( 0 );
     663                        commaExpr->env = appExpr->env;
     664                        appExpr->env = nullptr;
    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->get_returnVals().front()->get_type(), arg );
     710                                ret = addRetParam( appExpr, function->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->get_function(), adapteeType ) );
     717                        appExpr->get_args().push_front( new CastExpr( appExpr->function, adapteeType ) );
    718718                        appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
    719719
  • src/GenPoly/GenPoly.cc

    r157a816 rf57dd25  
    459459
    460460        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
    461                 // xxx - should this actually be insert?
    462                 tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };
     461                tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
    463462        }
    464463
  • src/GenPoly/Lvalue.cc

    r157a816 rf57dd25  
    2121#include "Lvalue.h"
    2222
     23#include "InitTweak/InitTweak.h"
    2324#include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
    2425#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
    2526#include "ResolvExpr/Unify.h"            // for unify
    2627#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
    3536
    3637#if 0
     
    4445                // TODO: fold this into the general createDeref function??
    4546                Expression * mkDeref( Expression * arg ) {
    46                         if ( SymTab::dereferenceOperator ) {
     47                        if ( Validate::dereferenceOperator ) {
    4748                                // 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
    48                                 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
     49                                VariableExpr * deref = new VariableExpr( Validate::dereferenceOperator );
    4950                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
    5051                                Type * base = InitTweak::getPointerBase( arg->result );
     
    353354                        Type * destType = castExpr->result;
    354355                        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 ) );
    355358                        int depth1 = destType->referenceDepth();
    356359                        int depth2 = srcType->referenceDepth();
  • src/GenPoly/ScopedSet.h

    r157a816 rf57dd25  
    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
    106108                private:
    107109                        scope_list const *scopes;
     
    180182                        bool operator!= (const const_iterator &that) { return !( *this == that ); }
    181183
     184                        size_type get_level() const { return i; }
     185
    182186                private:
    183187                        scope_list const *scopes;
     
    185189                        size_type i;
    186190                };
    187                
     191
    188192                /// Starts a new scope
    189193                void beginScope() {
     
    222226                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
    223227                }
    224                
     228
    225229                /// Finds the given key in the outermost scope inside the given scope where it occurs
    226230                iterator findNext( const_iterator &it, const Value &key ) {
     
    242246                        return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
    243247                }
    244                
     248
    245249        };
    246250} // namespace GenPoly
  • src/InitTweak/FixInit.cc

    r157a816 rf57dd25  
    5454#include "SynTree/Type.h"              // for Type, Type::StorageClasses
    5555#include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
     56#include "SynTree/DeclReplacer.h"      // for DeclReplacer
    5657#include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
     58#include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
    5759
    5860bool ctordtorp = false; // print all debug
     
    6668namespace InitTweak {
    6769        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 WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
     82                struct ResolveCopyCtors final : public WithStmtsToAdd, public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution, public WithVisitorRef<ResolveCopyCtors> {
    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, 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 );
     86                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
     87
     88                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
     89                        void premutate( StmtExpr * stmtExpr );
     90                        void premutate( UniqueExpr * unqExpr );
    9491
    9592                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
     
    9895                        bool skipCopyConstruct( Type * type );
    9996                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
    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;
     97                        void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr, Expression *& arg );
    10498                };
    10599
     
    162156                        using Parent::previsit;
    163157
    164                         void previsit( ObjectDecl * objDecl );
    165158                        void previsit( FunctionDecl * funcDecl );
    166159
    167                         void previsit( CompoundStmt * compoundStmt );
    168                         void postvisit( CompoundStmt * compoundStmt );
    169                         void previsit( ReturnStmt * returnStmt );
    170160                        void previsit( BranchStmt * stmt );
    171161                private:
     
    185175
    186176                        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;
    201177                };
    202178
     
    236212                        Expression * postmutate( ConstructorExpr * ctorExpr );
    237213                };
     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                };
    238222        } // namespace
    239223
     
    245229                InitTweak::fixGlobalInit( translationUnit, inLibrary );
    246230
    247                 UnqCount unqCount;
     231                // must happen before ResolveCopyCtors because temporaries have to be inserted into the correct scope
     232                SplitExpressions::split( translationUnit );
    248233
    249234                InsertImplicitCalls::insert( translationUnit );
    250                 ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
     235
     236                // Needs to happen before ResolveCopyCtors, because argument/return temporaries should not be considered in
     237                // error checking branch statements
    251238                InsertDtors::insert( translationUnit );
     239
     240                ResolveCopyCtors::resolveImplicitCalls( translationUnit );
    252241                FixInit::fixInitializers( translationUnit );
    253 
    254                 // FixCopyCtors must happen after FixInit, so that destructors are placed correctly
    255                 FixCopyCtors::fixCopyCtors( translationUnit, unqCount );
    256 
    257242                GenStructMemberCalls::generate( translationUnit );
    258243
    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.
     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.
    266246                FixCtorExprs::fix( translationUnit );
    267247        }
    268248
    269249        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
    270308                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
    271309                        PassVisitor<InsertImplicitCalls> inserter;
     
    273311                }
    274312
    275                 void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
    276                         PassVisitor<ResolveCopyCtors> resolver( unqCount );
    277                         acceptAll( translationUnit, resolver );
     313                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
     314                        PassVisitor<ResolveCopyCtors> resolver;
     315                        mutateAll( translationUnit, resolver );
    278316                }
    279317
     
    303341                }
    304342
    305                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
    306                         PassVisitor<FixCopyCtors> fixer( unqCount );
    307                         mutateAll( translationUnit, fixer );
    308                 }
    309 
    310343                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
    311344                        PassVisitor<GenStructMemberCalls> warner;
     
    318351                }
    319352
    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;
     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;
    368394                                                return;
    369395                                        }
    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                         }
     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;
    383426                }
    384427
     
    457500                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
    458501                                // fix newly generated StmtExpr
    459                                 postvisit( assign->stmtExpr );
     502                                premutate( assign->stmtExpr );
    460503                        }
    461504                        return resolved;
     
    489532                                        // so that the object isn't changed inside of the polymorphic function
    490533                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
     534                                        // xxx - leaking tmp
    491535                                }
    492536                        }
     
    496540
    497541                        // replace argument to function call with temporary
    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 ) {
     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 ) {
    508593                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
    509594
    510595                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
     596                        ObjectDecl * returnDecl = nullptr;
    511597
    512598                        // take each argument and attempt to copy construct it.
     
    517603                        for ( Expression * & arg : appExpr->args ) {
    518604                                Type * formal = nullptr;
    519                                 if ( iter != params.end() ) {
     605                                if ( iter != params.end() ) { // does not copy construct C-style variadic arguments
    520606                                        DeclarationWithType * param = *iter++;
    521607                                        formal = param->get_type();
     
    535621                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
    536622                                ret->type->set_const( false );
    537                                 impCpCtorExpr->returnDecls.push_back( ret );
     623                                returnDecl = ret;
     624                                stmtsToAddBefore.push_back( new DeclStmt( ret ) );
    538625                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
     626                        } // for
     627                        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 );
    539640                                if ( ! dynamic_cast< ReferenceType * >( result ) ) {
    540641                                        // 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                                 }
     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
     665                        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 );
    543671                        } // for
    544                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
    545                 }
    546 
    547                 void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
    548                         assert( env );
    549                         assert( stmtExpr->get_result() );
    550                         Type * result = stmtExpr->get_result();
     672
     673                        assert( stmtExpr->result );
     674                        Type * result = stmtExpr->result;
    551675                        if ( ! result->isVoid() ) {
    552676                                static UniqueName retNamer("_tmp_stmtexpr_ret");
     
    562686                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
    563687                                ret->type->set_const( false );
    564                                 stmtExpr->returnDecls.push_front( ret );
     688                                stmtsToAddBefore.push_back( new DeclStmt( ret ) );
    565689
    566690                                // must have a non-empty body, otherwise it wouldn't have a result
    567691                                CompoundStmt * body = stmtExpr->statements;
    568                                 assert( ! body->get_kids().empty() );
     692                                assert( ! body->kids.empty() );
    569693                                // must be an ExprStmt, otherwise it wouldn't have a result
    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 ) );
     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 ) ) );
    574705                        } // if
    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                         }
     706
     707                        assert( stmtExpr->returnDecls.empty() );
     708                        assert( stmtExpr->dtors.empty() );
    583709                }
    584710
     
    597723                }
    598724
    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() ) );
     725                void ResolveCopyCtors::premutate( UniqueExpr * unqExpr ) {
     726                        visit_children = false;
     727                        // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
     728                        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;
    611752                        } 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.
    676                         visit_children = false;
    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;
    709                         static std::unordered_map< int, UniqueExpr * > unqMap;
    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() ) ) {
    712753                                // take data from other UniqueExpr to ensure consistency
    713754                                delete unqExpr->get_expr();
    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;
     755                                unqExpr->expr = unqMap[unqExpr->get_id()]->expr->clone();
     756                                delete unqExpr->result;
     757                                unqExpr->result = maybeClone( unqExpr->expr->result );
     758                        }
    732759                }
    733760
     
    844871                                                        ctorInit->ctor = nullptr;
    845872                                                }
     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                                                }
    846888                                        } // if
    847889                                } else if ( Initializer * init = ctorInit->init ) {
     
    886928
    887929
    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 
    920930                void InsertDtors::previsit( FunctionDecl * funcDecl ) {
    921931                        // each function needs to have its own set of labels
     
    930940                }
    931941
    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 
    957942                // Handle break/continue/goto in the same manner as C++.  Basic idea: any objects that are in scope at the
    958943                // BranchStmt but not at the labelled (target) statement must be destructed.  If there are any objects in scope
     
    982967                        if ( ! diff.empty() ) {
    983968                                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 ) );
    1002969                        } // if
    1003970                }
     
    11161083                                                        callStmt->acceptMutator( *visitor );
    11171084                                                        if ( isCtor ) {
    1118                                                                 function->get_statements()->push_front( callStmt );
    1119                                                         } else {
     1085                                                                function->statements->push_front( callStmt );
     1086                                                        } else { // TODO: don't generate destructor function/object for intrinsic calls
    11201087                                                                // destructor statements should be added at the end
    1121                                                                 function->get_statements()->push_back( callStmt );
     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 );
    11221113                                                        }
    11231114                                                } catch ( SemanticErrorException & error ) {
  • src/InitTweak/GenInit.cc

    r157a816 rf57dd25  
    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, 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
     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
    4445
    4546namespace InitTweak {
     
    186187
    187188                        // need to resolve array dimensions in order to accurately determine if constexpr
    188                         ResolvExpr::findSingleExpression( arrayType->dimension, SymTab::SizeType->clone(), indexer );
     189                        ResolvExpr::findSingleExpression( arrayType->dimension, Validate::SizeType->clone(), indexer );
    189190                        // array is variable-length when the dimension is not constexpr
    190191                        arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
     
    192193                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
    193194
    194                         ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
     195                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
    195196                        arrayDimension->get_type()->set_const( true );
    196197
  • src/InitTweak/InitTweak.cc

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

    r157a816 rf57dd25  
    7070ARFLAGS     = cr
    7171
    72 demangler_SOURCES = SymTab/demangler.cc
     72demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
    7373
    7474demangler_LDADD = libdemangle.a -ldl                    # yywrap
  • src/Makefile.in

    r157a816 rf57dd25  
    234234        $(am__objects_7) Tuples/TupleAssignment.$(OBJEXT) \
    235235        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
    236         Validate/HandleAttributes.$(OBJEXT)
     236        Validate/HandleAttributes.$(OBJEXT) \
     237        Validate/FindSpecialDecls.$(OBJEXT)
    237238am_libdemangle_a_OBJECTS = $(am__objects_8)
    238239libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
     
    265266        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
    266267        Validate/HandleAttributes.$(OBJEXT) \
     268        Validate/FindSpecialDecls.$(OBJEXT) \
    267269        Virtual/ExpandCasts.$(OBJEXT)
    268270am____driver_cfa_cpp_OBJECTS = $(am__objects_9)
     
    555557        $(SRC_SYMTAB) $(SRC_SYNTREE) Tuples/TupleAssignment.cc \
    556558        Tuples/TupleExpansion.cc Tuples/Explode.cc \
    557         Validate/HandleAttributes.cc Virtual/ExpandCasts.cc
     559        Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc \
     560        Virtual/ExpandCasts.cc
    558561SRCDEMANGLE = CompilationState.cc $(SRC_AST) $(SRC_CODEGEN) \
    559562        Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
     
    562565        $(SRC_SYMTAB) SymTab/Demangle.cc $(SRC_SYNTREE) \
    563566        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    564         Tuples/Explode.cc Validate/HandleAttributes.cc
     567        Tuples/Explode.cc Validate/HandleAttributes.cc \
     568        Validate/FindSpecialDecls.cc
    565569MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
    566570MOSTLYCLEANFILES = Parser/lex.cc Parser/parser.cc Parser/parser.hh \
     
    685689AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
    686690ARFLAGS = cr
    687 demangler_SOURCES = SymTab/demangler.cc
     691demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
    688692demangler_LDADD = libdemangle.a -ldl                    # yywrap
    689693noinst_LIBRARIES = libdemangle.a
     
    10081012        @: > Validate/$(DEPDIR)/$(am__dirstamp)
    10091013Validate/HandleAttributes.$(OBJEXT): Validate/$(am__dirstamp) \
     1014        Validate/$(DEPDIR)/$(am__dirstamp)
     1015Validate/FindSpecialDecls.$(OBJEXT): Validate/$(am__dirstamp) \
    10101016        Validate/$(DEPDIR)/$(am__dirstamp)
    10111017
     
    13011307@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/TupleAssignment.Po@am__quote@
    13021308@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/TupleExpansion.Po@am__quote@
     1309@AMDEP_TRUE@@am__include@ @am__quote@Validate/$(DEPDIR)/FindSpecialDecls.Po@am__quote@
    13031310@AMDEP_TRUE@@am__include@ @am__quote@Validate/$(DEPDIR)/HandleAttributes.Po@am__quote@
    13041311@AMDEP_TRUE@@am__include@ @am__quote@Virtual/$(DEPDIR)/ExpandCasts.Po@am__quote@
  • src/Parser/parser.yy

    r157a816 rf57dd25  
    13451345
    13461346handler_clause:
    1347         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     1347        handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
    13481348                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
    1349         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
     1349        | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
    13501350                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
    13511351        ;
  • src/ResolvExpr/Resolver.cc

    r157a816 rf57dd25  
    4343#include "typeops.h"                     // for extractResultType
    4444#include "Unify.h"                       // for unify
     45#include "Validate/FindSpecialDecls.h"   // for SizeType
    4546
    4647using namespace std;
     
    235236                                winner.cost = winner.cvtCost;
    236237                        }
    237                        
     238
    238239                        // produce ambiguous errors, if applicable
    239240                        if ( winners.size() != 1 ) {
     
    255256
    256257                        // xxx - check for ambiguous expressions
    257                        
     258
    258259                        // output selected choice
    259260                        alt = std::move( choice );
     
    402403
    403404        void Resolver::previsit( ObjectDecl * objectDecl ) {
    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 
     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
    408409                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
    409410                GuardValue( currentObject );
     
    419420        void Resolver::handlePtrType( PtrType * type ) {
    420421                if ( type->get_dimension() ) {
    421                         findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
     422                        findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
    422423                }
    423424        }
     
    442443
    443444        void Resolver::postvisit( FunctionDecl * functionDecl ) {
    444                 // default value expressions have an environment which shouldn't be there and trips up 
     445                // default value expressions have an environment which shouldn't be there and trips up
    445446                // later passes.
    446                 // xxx - it might be necessary to somehow keep the information from this environment, but I 
     447                // xxx - it might be necessary to somehow keep the information from this environment, but I
    447448                // can't currently see how it's useful.
    448449                for ( Declaration * d : functionDecl->type->parameters ) {
     
    795796                initExpr->expr = nullptr;
    796797                std::swap( initExpr->env, newExpr->env );
    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 
     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
    799800                // sufficient.
    800801                newExpr->spliceInferParams( initExpr );
    801802                delete initExpr;
    802803
    803                 // get the actual object's type (may not exactly match what comes back from the resolver 
     804                // get the actual object's type (may not exactly match what comes back from the resolver
    804805                // due to conversions)
    805806                Type * initContext = currentObject.getCurrentType();
     
    814815                                        if ( isCharType( pt->get_base() ) ) {
    815816                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
    816                                                         // strip cast if we're initializing a char[] with a char *, 
     817                                                        // strip cast if we're initializing a char[] with a char *,
    817818                                                        // e.g.  char x[] = "hello";
    818819                                                        newExpr = ce->get_arg();
     
    837838                // move cursor into brace-enclosed initializer-list
    838839                currentObject.enterListInit();
    839                 // xxx - fix this so that the list isn't copied, iterator should be used to change current 
     840                // xxx - fix this so that the list isn't copied, iterator should be used to change current
    840841                // element
    841842                std::list<Designation *> newDesignations;
    842843                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
    843                         // iterate designations and initializers in pairs, moving the cursor to the current 
     844                        // iterate designations and initializers in pairs, moving the cursor to the current
    844845                        // designated object and resolving the initializer against that object.
    845846                        Designation * des = std::get<0>(p);
  • src/SymTab/Autogen.cc

    r157a816 rf57dd25  
    4141
    4242namespace SymTab {
    43         Type * SizeType = 0;
    44 
    4543        /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
    4644        struct FuncData {
    47                 typedef FunctionType * (*TypeGen)( Type * );
     45                typedef FunctionType * (*TypeGen)( Type *, bool );
    4846                FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
    4947                std::string fname;
     
    231229
    232230        /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
    233         FunctionType * genDefaultType( Type * paramType ) {
    234                 const auto & typeParams = getGenericParams( paramType );
     231        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
    235232                FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
    236                 cloneAll( typeParams, ftype->forall );
     233                if ( maybePolymorphic ) {
     234                        // only copy in
     235                        const auto & typeParams = getGenericParams( paramType );
     236                        cloneAll( typeParams, ftype->forall );
     237                }
    237238                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
    238239                ftype->parameters.push_back( dstParam );
     
    241242
    242243        /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
    243         FunctionType * genCopyType( Type * paramType ) {
    244                 FunctionType *ftype = genDefaultType( paramType );
     244        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic ) {
     245                FunctionType *ftype = genDefaultType( paramType, maybePolymorphic );
    245246                ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    246247                ftype->parameters.push_back( srcParam );
     
    249250
    250251        /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
    251         FunctionType * genAssignType( Type * paramType ) {
    252                 FunctionType *ftype = genCopyType( paramType );
     252        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic ) {
     253                FunctionType *ftype = genCopyType( paramType, maybePolymorphic );
    253254                ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    254255                ftype->returnVals.push_back( returnVal );
     
    308309                for ( const FuncData & d : data ) {
    309310                        // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
    310                         FunctionType * ftype = d.genType( type );
     311                        FunctionType * ftype = d.genType( type, true );
    311312
    312313                        // destructor for concurrent type must be mutex
  • src/SymTab/Autogen.h

    r157a816 rf57dd25  
    3737        bool isUnnamedBitfield( ObjectDecl * obj );
    3838
    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 );
     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 );
    5550
    5651        /// 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

    r157a816 rf57dd25  
    7676#include "SynTree/Visitor.h"           // for Visitor
    7777#include "Validate/HandleAttributes.h" // for handleAttributes
     78#include "Validate/FindSpecialDecls.h" // for FindSpecialDecls
    7879
    7980class CompoundStmt;
     
    288289        };
    289290
    290         FunctionDecl * dereferenceOperator = nullptr;
    291         struct FindSpecialDeclarations final {
    292                 void previsit( FunctionDecl * funcDecl );
    293         };
    294 
    295291        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
    296292                PassVisitor<EnumAndPointerDecay> epc;
     
    299295                PassVisitor<CompoundLiteral> compoundliteral;
    300296                PassVisitor<ValidateGenericParameters> genericParams;
    301                 PassVisitor<FindSpecialDeclarations> finder;
    302297                PassVisitor<LabelAddressFixer> labelAddrFixer;
    303298                PassVisitor<HoistTypeDecls> hoistDecls;
     
    378373                        });
    379374                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
    380                                 acceptAll( translationUnit, finder ); // xxx - remove this pass soon
     375                                Validate::findSpecialDecls( translationUnit );
    381376                        });
    382377                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
     
    943938                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
    944939                        // grab and remember declaration of size_t
    945                         SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
     940                        Validate::SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
    946941                } else {
    947942                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
    948943                        // eventually should have a warning for this case.
    949                         SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
     944                        Validate::SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
    950945                }
    951946        }
     
    13351330                        // need to resolve array dimensions early so that constructor code can correctly determine
    13361331                        // if a type is a VLA (and hence whether its elements need to be constructed)
    1337                         ResolvExpr::findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
     1332                        ResolvExpr::findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
    13381333
    13391334                        // must re-evaluate whether a type is a VLA, now that more information is available
     
    13721367                return addrExpr;
    13731368        }
    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         }
    13851369} // namespace SymTab
    13861370
  • src/SynTree/DeclReplacer.cc

    r157a816 rf57dd25  
    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                };
    4052        }
    4153
     
    5365                DeclMap declMap;
    5466                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 );
    5572        }
    5673
     
    7996                        }
    8097                }
     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                }
    81113        }
    82114} // namespace VarExprReplacer
  • src/SynTree/DeclReplacer.h

    r157a816 rf57dd25  
    2626        typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
    2727        typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
     28        typedef std::map< DeclarationWithType *, Expression * > ExprMap;
    2829
    2930        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
    3031        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
    3132        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        }
    3243}
    3344
  • src/SynTree/Expression.cc

    r157a816 rf57dd25  
    538538        assert( callExpr );
    539539        assert( callExpr->result );
    540         set_result( callExpr->get_result()->clone() );
     540        set_result( callExpr->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 );
    547544}
    548545
     
    550547        set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
    551548        delete callExpr;
    552         deleteAll( tempDecls );
    553         deleteAll( returnDecls );
    554         deleteAll( dtors );
    555549}
    556550
     
    558552        os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
    559553        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 );
    565554}
    566555
  • src/SynTree/Expression.h

    r157a816 rf57dd25  
    593593class ImplicitCopyCtorExpr : public Expression {
    594594public:
    595         ApplicationExpr * callExpr;
    596         std::list< ObjectDecl * > tempDecls;
    597         std::list< ObjectDecl * > returnDecls;
    598         std::list< Expression * > dtors;
     595        ApplicationExpr * callExpr = nullptr;
    599596
    600597        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
    601598        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
    602599        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; }
    610600
    611601        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
  • src/Validate/module.mk

    r157a816 rf57dd25  
    1515###############################################################################
    1616
    17 SRC += Validate/HandleAttributes.cc
    18 SRCDEMANGLE += Validate/HandleAttributes.cc
     17SRC += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
     18SRCDEMANGLE += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
  • src/Virtual/ExpandCasts.cc

    r157a816 rf57dd25  
    147147                                //              )
    148148                                //      ),
    149                         new UntypedExpr( new NameExpr( "__cfa__virtual_cast" ), {
     149                        new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
    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

    r157a816 rf57dd25  
    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     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     19    {
     20        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     21    }
     22
    2023}
    2124static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     25    {
     26        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     27    }
     28
    2329}
    2430static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    25     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     31    {
     32        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     33    }
     34
    2635}
    2736static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    2837    struct S _X4_retS1S_1;
    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)));
     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
    3146    return _X4_retS1S_1;
    3247}
    3348static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    34     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     49    {
     50        ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     51    }
     52
    3553}
    3654signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
     
    5977    __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    6078    signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
     79    {
     80        ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
     81    }
     82
    6283    return _X11_retval_f10FPi_ii__1;
    6384}
     
    82103    signed int _X1ai_2;
    83104    signed int _X1bi_2;
    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) /* ^?{} */);
     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
    87110    const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    88111        __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
  • tests/.expect/KRfunctions.x86.txt

    r157a816 rf57dd25  
    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     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     19    {
     20        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     21    }
     22
    2023}
    2124static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     25    {
     26        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     27    }
     28
    2329}
    2430static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    25     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     31    {
     32        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     33    }
     34
    2635}
    2736static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    2837    struct S _X4_retS1S_1;
    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)));
     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
    3146    return _X4_retS1S_1;
    3247}
    3348static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    34     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     49    {
     50        ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     51    }
     52
    3553}
    3654signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
     
    5977    __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    6078    signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
     79    {
     80        ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
     81    }
     82
    6283    return _X11_retval_f10FPi_ii__1;
    6384}
     
    82103    signed int _X1ai_2;
    83104    signed int _X1bi_2;
    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) /* ^?{} */);
     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
    87110    const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    88111        __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
  • tests/.expect/attributes.x64.txt

    r157a816 rf57dd25  
    11signed int _X2laFi___1(){
    22    __attribute__ ((unused)) signed int _X10_retval_lai_1;
    3     L: __attribute__ ((unused)) ((void)1);
     3    {
     4        L: __attribute__ ((unused)) ((void)1);
     5    }
     6
    47}
    58struct __attribute__ ((unused)) __anonymous0 {
     
    1720static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    1821    struct __anonymous0 _X4_retS12__anonymous0_1;
    19     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
     22    {
     23        ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
     24    }
     25
    2026    return _X4_retS12__anonymous0_1;
    2127}
     
    3541static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    3642    struct Agn2 _X4_retS4Agn2_1;
    37     ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
     43    {
     44        ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
     45    }
     46
    3847    return _X4_retS4Agn2_1;
    3948}
     
    5968static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    6069    struct __anonymous2 _X4_retS12__anonymous2_1;
    61     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
     70    {
     71        ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
     72    }
     73
    6274    return _X4_retS12__anonymous2_1;
    6375}
     
    7688static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    7789    struct Agn4 _X4_retS4Agn4_1;
    78     ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
     90    {
     91        ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
     92    }
     93
    7994    return _X4_retS4Agn4_1;
    8095}
     
    104119static 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);
    105120static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    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) /* ?{} */);
     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
    115157}
    116158static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    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) /* ?{} */);
     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
    126195}
    127196static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    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) /* ^?{} */);
     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
    137233}
    138234static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    139235    struct Fdl _X4_retS3Fdl_1;
    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)));
     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
    150276    return _X4_retS3Fdl_1;
    151277}
    152278static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    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) /* ?{} */);
     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
    162315}
    163316static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    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) /* ?{} */);
     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
    173353}
    174354static 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){
    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) /* ?{} */);
     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
    184391}
    185392static 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){
    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) /* ?{} */);
     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
    195429}
    196430static 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){
    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) /* ?{} */);
     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
    206467}
    207468static 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){
    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) /* ?{} */);
     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
    217505}
    218506static 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){
    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) /* ?{} */);
     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
    228543}
    229544static 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){
    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) /* ?{} */);
     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
    239581}
    240582static 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){
    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) /* ?{} */);
     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
    250619}
    251620__attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
     
    314683    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    315684    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
    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 ()));
     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
    321705    struct __attribute__ ((unused)) __anonymous3 {
    322706        signed int _X1ii_2;
    323707    };
    324708    inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    325         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
     709        {
     710            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
     711        }
     712
    326713    }
    327714    inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    328         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
     715        {
     716            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
     717        }
     718
    329719    }
    330720    inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    331         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
     721        {
     722            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
     723        }
     724
    332725    }
    333726    inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    334727        struct __anonymous3 _X4_retS12__anonymous3_2;
    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)));
     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
    337736        return _X4_retS12__anonymous3_2;
    338737    }
    339738    inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    340         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    341     }
    342     ((void)sizeof(struct __anonymous3 ));
     739        {
     740            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     741        }
     742
     743    }
     744    {
     745        ((void)sizeof(struct __anonymous3 ));
     746    }
     747
    343748    enum __attribute__ ((unused)) __anonymous4 {
    344749        _X1RKM12__anonymous4_2,
     
    347752    }
    348753    inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    349         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
     754        {
     755            ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
     756        }
     757
    350758    }
    351759    inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
     
    353761    inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    354762        enum __anonymous4 _X4_retM12__anonymous4_2;
    355         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    356         ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__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
    357771        return _X4_retM12__anonymous4_2;
    358772    }
    359     ((void)sizeof(enum __anonymous4 ));
     773    {
     774        ((void)sizeof(enum __anonymous4 ));
     775    }
     776
    360777}
    361778signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
     
    383800static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    384801    struct Vad _X4_retS3Vad_1;
    385     ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
     802    {
     803        ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
     804    }
     805
    386806    return _X4_retS3Vad_1;
    387807}
  • tests/.expect/attributes.x86.txt

    r157a816 rf57dd25  
    11signed int _X2laFi___1(){
    22    __attribute__ ((unused)) signed int _X10_retval_lai_1;
    3     L: __attribute__ ((unused)) ((void)1);
     3    {
     4        L: __attribute__ ((unused)) ((void)1);
     5    }
     6
    47}
    58struct __attribute__ ((unused)) __anonymous0 {
     
    1720static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    1821    struct __anonymous0 _X4_retS12__anonymous0_1;
    19     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
     22    {
     23        ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
     24    }
     25
    2026    return _X4_retS12__anonymous0_1;
    2127}
     
    3541static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    3642    struct Agn2 _X4_retS4Agn2_1;
    37     ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
     43    {
     44        ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
     45    }
     46
    3847    return _X4_retS4Agn2_1;
    3948}
     
    5968static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    6069    struct __anonymous2 _X4_retS12__anonymous2_1;
    61     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
     70    {
     71        ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
     72    }
     73
    6274    return _X4_retS12__anonymous2_1;
    6375}
     
    7688static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    7789    struct Agn4 _X4_retS4Agn4_1;
    78     ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
     90    {
     91        ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
     92    }
     93
    7994    return _X4_retS4Agn4_1;
    8095}
     
    104119static 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);
    105120static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    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) /* ?{} */);
     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
    115157}
    116158static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    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) /* ?{} */);
     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
    126195}
    127196static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    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) /* ^?{} */);
     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
    137233}
    138234static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    139235    struct Fdl _X4_retS3Fdl_1;
    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)));
     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
    150276    return _X4_retS3Fdl_1;
    151277}
    152278static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    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) /* ?{} */);
     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
    162315}
    163316static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    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) /* ?{} */);
     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
    173353}
    174354static 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){
    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) /* ?{} */);
     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
    184391}
    185392static 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){
    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) /* ?{} */);
     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
    195429}
    196430static 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){
    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) /* ?{} */);
     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
    206467}
    207468static 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){
    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) /* ?{} */);
     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
    217505}
    218506static 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){
    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) /* ?{} */);
     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
    228543}
    229544static 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){
    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) /* ?{} */);
     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
    239581}
    240582static 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){
    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) /* ?{} */);
     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
    250619}
    251620__attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
     
    314683    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    315684    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
    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 ()));
     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
    321705    struct __attribute__ ((unused)) __anonymous3 {
    322706        signed int _X1ii_2;
    323707    };
    324708    inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    325         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
     709        {
     710            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
     711        }
     712
    326713    }
    327714    inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    328         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
     715        {
     716            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
     717        }
     718
    329719    }
    330720    inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    331         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
     721        {
     722            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
     723        }
     724
    332725    }
    333726    inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    334727        struct __anonymous3 _X4_retS12__anonymous3_2;
    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)));
     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
    337736        return _X4_retS12__anonymous3_2;
    338737    }
    339738    inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    340         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    341     }
    342     ((void)sizeof(struct __anonymous3 ));
     739        {
     740            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     741        }
     742
     743    }
     744    {
     745        ((void)sizeof(struct __anonymous3 ));
     746    }
     747
    343748    enum __attribute__ ((unused)) __anonymous4 {
    344749        _X1RKM12__anonymous4_2,
     
    347752    }
    348753    inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    349         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
     754        {
     755            ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
     756        }
     757
    350758    }
    351759    inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
     
    353761    inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    354762        enum __anonymous4 _X4_retM12__anonymous4_2;
    355         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    356         ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__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
    357771        return _X4_retM12__anonymous4_2;
    358772    }
    359     ((void)sizeof(enum __anonymous4 ));
     773    {
     774        ((void)sizeof(enum __anonymous4 ));
     775    }
     776
    360777}
    361778signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
     
    383800static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    384801    struct Vad _X4_retS3Vad_1;
    385     ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
     802    {
     803        ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
     804    }
     805
    386806    return _X4_retS3Vad_1;
    387807}
  • tests/.expect/completeTypeError.txt

    r157a816 rf57dd25  
    2727   void
    2828 )
    29  Environment:( _80_4_DT ) -> instance of struct A with body 0 (no widening)
     29 Environment:( _82_4_DT ) -> instance of struct A with body 0 (no widening)
    3030
    3131
     
    5050   void
    5151 )
    52  Environment:( _80_4_DT ) -> instance of struct B with body 1 (no widening)
     52 Environment:( _82_4_DT ) -> instance of struct B with body 1 (no widening)
    5353
    5454
     
    127127       void
    128128     )
    129      Environment:( _99_0_T ) -> instance of type T (not function type) (no widening)
     129     Environment:( _101_0_T ) -> instance of type T (not function type) (no widening)
    130130
    131131   Could not satisfy assertion:
    132132?=?: pointer to function
    133133     ... with parameters
    134        reference to instance of type _99_0_T (not function type)
    135        instance of type _99_0_T (not function type)
     134       reference to instance of type _101_0_T (not function type)
     135       instance of type _101_0_T (not function type)
    136136     ... returning
    137        _retval__operator_assign: instance of type _99_0_T (not function type)
     137       _retval__operator_assign: instance of type _101_0_T (not function type)
    138138       ... with attributes:
    139139         Attribute with name: unused
  • tests/.expect/declarationSpecifier.x64.txt

    r157a816 rf57dd25  
    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     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
     18    {
     19        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
     20    }
     21
    1922}
    2023static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    21     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
     24    {
     25        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
     26    }
     27
    2228}
    2329static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    24     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
     30    {
     31        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
     32    }
     33
    2534}
    2635static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    2736    struct __anonymous0 _X4_retS12__anonymous0_1;
    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)));
     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
    3045    return _X4_retS12__anonymous0_1;
    3146}
    3247static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    33     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
     48    {
     49        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
     50    }
     51
    3452}
    3553volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
     
    4361static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    4462static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    45     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
     63    {
     64        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
     65    }
     66
    4667}
    4768static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    48     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
     69    {
     70        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
     71    }
     72
    4973}
    5074static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    51     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
     75    {
     76        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
     77    }
     78
    5279}
    5380static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    5481    struct __anonymous1 _X4_retS12__anonymous1_1;
    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)));
     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
    5790    return _X4_retS12__anonymous1_1;
    5891}
    5992static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    60     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
     93    {
     94        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
     95    }
     96
    6197}
    6298volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
     
    70106static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    71107static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    72     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
     108    {
     109        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
     110    }
     111
    73112}
    74113static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    75     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
     114    {
     115        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
     116    }
     117
    76118}
    77119static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    78     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
     120    {
     121        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
     122    }
     123
    79124}
    80125static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    81126    struct __anonymous2 _X4_retS12__anonymous2_1;
    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)));
     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
    84135    return _X4_retS12__anonymous2_1;
    85136}
    86137static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    87     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
     138    {
     139        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
     140    }
     141
    88142}
    89143volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
     
    97151static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    98152static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    99     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
     153    {
     154        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
     155    }
     156
    100157}
    101158static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    102     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
     159    {
     160        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
     161    }
     162
    103163}
    104164static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    105     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
     165    {
     166        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
     167    }
     168
    106169}
    107170static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    108171    struct __anonymous3 _X4_retS12__anonymous3_1;
    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)));
     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
    111180    return _X4_retS12__anonymous3_1;
    112181}
    113182static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    114     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
     183    {
     184        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
     185    }
     186
    115187}
    116188static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
     
    124196static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    125197static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    126     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
     198    {
     199        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
     200    }
     201
    127202}
    128203static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    129     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
     204    {
     205        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
     206    }
     207
    130208}
    131209static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    132     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
     210    {
     211        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
     212    }
     213
    133214}
    134215static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    135216    struct __anonymous4 _X4_retS12__anonymous4_1;
    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)));
     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
    138225    return _X4_retS12__anonymous4_1;
    139226}
    140227static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    141     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
     228    {
     229        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
     230    }
     231
    142232}
    143233static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
     
    151241static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    152242static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    153     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
     243    {
     244        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
     245    }
     246
    154247}
    155248static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    156     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
     249    {
     250        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
     251    }
     252
    157253}
    158254static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    159     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
     255    {
     256        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
     257    }
     258
    160259}
    161260static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    162261    struct __anonymous5 _X4_retS12__anonymous5_1;
    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)));
     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
    165270    return _X4_retS12__anonymous5_1;
    166271}
    167272static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    168     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
     273    {
     274        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
     275    }
     276
    169277}
    170278static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
     
    178286static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    179287static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    180     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
     288    {
     289        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
     290    }
     291
    181292}
    182293static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    183     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
     294    {
     295        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
     296    }
     297
    184298}
    185299static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    186     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
     300    {
     301        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
     302    }
     303
    187304}
    188305static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    189306    struct __anonymous6 _X4_retS12__anonymous6_1;
    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)));
     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
    192315    return _X4_retS12__anonymous6_1;
    193316}
    194317static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    195     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
     318    {
     319        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
     320    }
     321
    196322}
    197323static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
     
    205331static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    206332static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    207     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
     333    {
     334        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
     335    }
     336
    208337}
    209338static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    210     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
     339    {
     340        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
     341    }
     342
    211343}
    212344static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    213     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
     345    {
     346        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
     347    }
     348
    214349}
    215350static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    216351    struct __anonymous7 _X4_retS12__anonymous7_1;
    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)));
     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
    219360    return _X4_retS12__anonymous7_1;
    220361}
    221362static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    222     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
     363    {
     364        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
     365    }
     366
    223367}
    224368static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
     
    240384static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    241385static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    242     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
     386    {
     387        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
     388    }
     389
    243390}
    244391static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    245     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
     392    {
     393        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
     394    }
     395
    246396}
    247397static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    248     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
     398    {
     399        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
     400    }
     401
    249402}
    250403static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    251404    struct __anonymous8 _X4_retS12__anonymous8_1;
    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)));
     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
    254413    return _X4_retS12__anonymous8_1;
    255414}
    256415static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
    257     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
     416    {
     417        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
     418    }
     419
    258420}
    259421volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
     
    267429static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
    268430static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    269     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
     431    {
     432        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
     433    }
     434
    270435}
    271436static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    272     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
     437    {
     438        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
     439    }
     440
    273441}
    274442static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    275     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
     443    {
     444        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
     445    }
     446
    276447}
    277448static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    278449    struct __anonymous9 _X4_retS12__anonymous9_1;
    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)));
     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
    281458    return _X4_retS12__anonymous9_1;
    282459}
    283460static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
    284     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
     461    {
     462        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
     463    }
     464
    285465}
    286466volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
     
    294474static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
    295475static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    296     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
     476    {
     477        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
     478    }
     479
    297480}
    298481static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    299     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
     482    {
     483        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
     484    }
     485
    300486}
    301487static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    302     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
     488    {
     489        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
     490    }
     491
    303492}
    304493static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    305494    struct __anonymous10 _X4_retS13__anonymous10_1;
    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)));
     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
    308503    return _X4_retS13__anonymous10_1;
    309504}
    310505static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
    311     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
     506    {
     507        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
     508    }
     509
    312510}
    313511volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
     
    321519static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
    322520static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    323     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
     521    {
     522        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
     523    }
     524
    324525}
    325526static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    326     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
     527    {
     528        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
     529    }
     530
    327531}
    328532static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    329     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
     533    {
     534        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
     535    }
     536
    330537}
    331538static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    332539    struct __anonymous11 _X4_retS13__anonymous11_1;
    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)));
     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
    335548    return _X4_retS13__anonymous11_1;
    336549}
    337550static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
    338     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
     551    {
     552        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
     553    }
     554
    339555}
    340556static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
     
    348564static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
    349565static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    350     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
     566    {
     567        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
     568    }
     569
    351570}
    352571static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    353     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
     572    {
     573        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
     574    }
     575
    354576}
    355577static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    356     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
     578    {
     579        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
     580    }
     581
    357582}
    358583static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    359584    struct __anonymous12 _X4_retS13__anonymous12_1;
    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)));
     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
    362593    return _X4_retS13__anonymous12_1;
    363594}
    364595static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
    365     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
     596    {
     597        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
     598    }
     599
    366600}
    367601static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
     
    375609static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
    376610static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    377     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
     611    {
     612        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
     613    }
     614
    378615}
    379616static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    380     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
     617    {
     618        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
     619    }
     620
    381621}
    382622static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    383     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
     623    {
     624        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
     625    }
     626
    384627}
    385628static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    386629    struct __anonymous13 _X4_retS13__anonymous13_1;
    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)));
     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
    389638    return _X4_retS13__anonymous13_1;
    390639}
    391640static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
    392     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
     641    {
     642        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
     643    }
     644
    393645}
    394646static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
     
    402654static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
    403655static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    404     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
     656    {
     657        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
     658    }
     659
    405660}
    406661static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    407     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
     662    {
     663        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
     664    }
     665
    408666}
    409667static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    410     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
     668    {
     669        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
     670    }
     671
    411672}
    412673static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    413674    struct __anonymous14 _X4_retS13__anonymous14_1;
    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)));
     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
    416683    return _X4_retS13__anonymous14_1;
    417684}
    418685static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
    419     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
     686    {
     687        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
     688    }
     689
    420690}
    421691static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
     
    429699static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
    430700static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    431     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
     701    {
     702        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
     703    }
     704
    432705}
    433706static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    434     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
     707    {
     708        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
     709    }
     710
    435711}
    436712static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    437     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
     713    {
     714        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
     715    }
     716
    438717}
    439718static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    440719    struct __anonymous15 _X4_retS13__anonymous15_1;
    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)));
     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
    443728    return _X4_retS13__anonymous15_1;
    444729}
    445730static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
    446     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
     731    {
     732        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
     733    }
     734
    447735}
    448736static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
     
    472760static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
    473761static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    474     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
     762    {
     763        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
     764    }
     765
    475766}
    476767static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    477     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
     768    {
     769        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
     770    }
     771
    478772}
    479773static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    480     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
     774    {
     775        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
     776    }
     777
    481778}
    482779static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    483780    struct __anonymous16 _X4_retS13__anonymous16_1;
    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)));
     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
    486789    return _X4_retS13__anonymous16_1;
    487790}
    488791static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
    489     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
     792    {
     793        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
     794    }
     795
    490796}
    491797static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
     
    499805static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
    500806static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    501     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
     807    {
     808        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
     809    }
     810
    502811}
    503812static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    504     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
     813    {
     814        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
     815    }
     816
    505817}
    506818static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    507     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
     819    {
     820        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
     821    }
     822
    508823}
    509824static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    510825    struct __anonymous17 _X4_retS13__anonymous17_1;
    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)));
     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
    513834    return _X4_retS13__anonymous17_1;
    514835}
    515836static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
    516     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
     837    {
     838        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
     839    }
     840
    517841}
    518842static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
     
    526850static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
    527851static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    528     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
     852    {
     853        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
     854    }
     855
    529856}
    530857static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    531     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
     858    {
     859        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
     860    }
     861
    532862}
    533863static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    534     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
     864    {
     865        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
     866    }
     867
    535868}
    536869static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    537870    struct __anonymous18 _X4_retS13__anonymous18_1;
    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)));
     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
    540879    return _X4_retS13__anonymous18_1;
    541880}
    542881static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
    543     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
     882    {
     883        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
     884    }
     885
    544886}
    545887static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
     
    553895static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
    554896static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    555     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
     897    {
     898        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
     899    }
     900
    556901}
    557902static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    558     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
     903    {
     904        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
     905    }
     906
    559907}
    560908static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    561     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
     909    {
     910        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
     911    }
     912
    562913}
    563914static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    564915    struct __anonymous19 _X4_retS13__anonymous19_1;
    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)));
     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
    567924    return _X4_retS13__anonymous19_1;
    568925}
    569926static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
    570     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
     927    {
     928        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
     929    }
     930
    571931}
    572932static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
     
    580940static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
    581941static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    582     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
     942    {
     943        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
     944    }
     945
    583946}
    584947static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    585     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
     948    {
     949        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
     950    }
     951
    586952}
    587953static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    588     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
     954    {
     955        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
     956    }
     957
    589958}
    590959static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    591960    struct __anonymous20 _X4_retS13__anonymous20_1;
    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)));
     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
    594969    return _X4_retS13__anonymous20_1;
    595970}
    596971static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
    597     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
     972    {
     973        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
     974    }
     975
    598976}
    599977static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
     
    607985static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
    608986static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    609     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
     987    {
     988        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
     989    }
     990
    610991}
    611992static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    612     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
     993    {
     994        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
     995    }
     996
    613997}
    614998static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    615     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
     999    {
     1000        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
     1001    }
     1002
    6161003}
    6171004static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    6181005    struct __anonymous21 _X4_retS13__anonymous21_1;
    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)));
     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
    6211014    return _X4_retS13__anonymous21_1;
    6221015}
    6231016static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
    624     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1017    {
     1018        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1019    }
     1020
    6251021}
    6261022static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
     
    6341030static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
    6351031static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    636     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
     1032    {
     1033        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
     1034    }
     1035
    6371036}
    6381037static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    639     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
     1038    {
     1039        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
     1040    }
     1041
    6401042}
    6411043static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    642     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
     1044    {
     1045        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
     1046    }
     1047
    6431048}
    6441049static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    6451050    struct __anonymous22 _X4_retS13__anonymous22_1;
    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)));
     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
    6481059    return _X4_retS13__anonymous22_1;
    6491060}
    6501061static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
    651     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1062    {
     1063        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1064    }
     1065
    6521066}
    6531067static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
     
    6611075static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
    6621076static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    663     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
     1077    {
     1078        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
     1079    }
     1080
    6641081}
    6651082static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    666     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
     1083    {
     1084        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
     1085    }
     1086
    6671087}
    6681088static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    669     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
     1089    {
     1090        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
     1091    }
     1092
    6701093}
    6711094static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    6721095    struct __anonymous23 _X4_retS13__anonymous23_1;
    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)));
     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
    6751104    return _X4_retS13__anonymous23_1;
    6761105}
    6771106static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
    678     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1107    {
     1108        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
     1109    }
     1110
    6791111}
    6801112static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
     
    6891121signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    6901122    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    691     ((void)(_X12_retval_maini_1=0) /* ?{} */);
     1123    {
     1124        ((void)(_X12_retval_maini_1=0) /* ?{} */);
     1125    }
     1126
    6921127    return _X12_retval_maini_1;
    6931128}
     
    6961131signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    6971132    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    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) /* ^?{} */);
     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
    7011138    return _X12_retval_maini_1;
    7021139}
  • tests/.expect/declarationSpecifier.x86.txt

    r157a816 rf57dd25  
    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     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
     18    {
     19        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
     20    }
     21
    1922}
    2023static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    21     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
     24    {
     25        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
     26    }
     27
    2228}
    2329static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    24     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
     30    {
     31        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
     32    }
     33
    2534}
    2635static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    2736    struct __anonymous0 _X4_retS12__anonymous0_1;
    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)));
     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
    3045    return _X4_retS12__anonymous0_1;
    3146}
    3247static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    33     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
     48    {
     49        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
     50    }
     51
    3452}
    3553volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
     
    4361static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    4462static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    45     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
     63    {
     64        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
     65    }
     66
    4667}
    4768static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    48     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
     69    {
     70        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
     71    }
     72
    4973}
    5074static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    51     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
     75    {
     76        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
     77    }
     78
    5279}
    5380static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    5481    struct __anonymous1 _X4_retS12__anonymous1_1;
    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)));
     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
    5790    return _X4_retS12__anonymous1_1;
    5891}
    5992static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    60     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
     93    {
     94        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
     95    }
     96
    6197}
    6298volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
     
    70106static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    71107static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    72     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
     108    {
     109        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
     110    }
     111
    73112}
    74113static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    75     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
     114    {
     115        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
     116    }
     117
    76118}
    77119static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    78     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
     120    {
     121        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
     122    }
     123
    79124}
    80125static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    81126    struct __anonymous2 _X4_retS12__anonymous2_1;
    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)));
     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
    84135    return _X4_retS12__anonymous2_1;
    85136}
    86137static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    87     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
     138    {
     139        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
     140    }
     141
    88142}
    89143volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
     
    97151static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    98152static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    99     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
     153    {
     154        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
     155    }
     156
    100157}
    101158static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    102     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
     159    {
     160        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
     161    }
     162
    103163}
    104164static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    105     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
     165    {
     166        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
     167    }
     168
    106169}
    107170static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    108171    struct __anonymous3 _X4_retS12__anonymous3_1;
    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)));
     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
    111180    return _X4_retS12__anonymous3_1;
    112181}
    113182static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    114     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
     183    {
     184        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
     185    }
     186
    115187}
    116188static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
     
    124196static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    125197static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    126     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
     198    {
     199        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
     200    }
     201
    127202}
    128203static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    129     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
     204    {
     205        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
     206    }
     207
    130208}
    131209static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    132     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
     210    {
     211        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
     212    }
     213
    133214}
    134215static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    135216    struct __anonymous4 _X4_retS12__anonymous4_1;
    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)));
     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
    138225    return _X4_retS12__anonymous4_1;
    139226}
    140227static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    141     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
     228    {
     229        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
     230    }
     231
    142232}
    143233static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
     
    151241static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    152242static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    153     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
     243    {
     244        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
     245    }
     246
    154247}
    155248static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    156     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
     249    {
     250        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
     251    }
     252
    157253}
    158254static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    159     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
     255    {
     256        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
     257    }
     258
    160259}
    161260static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    162261    struct __anonymous5 _X4_retS12__anonymous5_1;
    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)));
     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
    165270    return _X4_retS12__anonymous5_1;
    166271}
    167272static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    168     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
     273    {
     274        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
     275    }
     276
    169277}
    170278static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
     
    178286static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    179287static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    180     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
     288    {
     289        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
     290    }
     291
    181292}
    182293static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    183     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
     294    {
     295        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
     296    }
     297
    184298}
    185299static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    186     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
     300    {
     301        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
     302    }
     303
    187304}
    188305static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    189306    struct __anonymous6 _X4_retS12__anonymous6_1;
    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)));
     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
    192315    return _X4_retS12__anonymous6_1;
    193316}
    194317static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    195     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
     318    {
     319        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
     320    }
     321
    196322}
    197323static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
     
    205331static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    206332static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    207     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
     333    {
     334        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
     335    }
     336
    208337}
    209338static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    210     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
     339    {
     340        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
     341    }
     342
    211343}
    212344static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    213     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
     345    {
     346        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
     347    }
     348
    214349}
    215350static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    216351    struct __anonymous7 _X4_retS12__anonymous7_1;
    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)));
     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
    219360    return _X4_retS12__anonymous7_1;
    220361}
    221362static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    222     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
     363    {
     364        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
     365    }
     366
    223367}
    224368static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
     
    240384static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    241385static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    242     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
     386    {
     387        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
     388    }
     389
    243390}
    244391static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    245     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);