Changeset ae32d96


Ignore:
Timestamp:
May 30, 2018, 5:57:43 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, with_gc
Children:
597c34a3, 6810fcb, 94b1022a, cf5e5b1
Parents:
6b4cdd3 (diff), d15a45d (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 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    r6b4cdd3 rae32d96  
    172172        // *** Declarations
    173173        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
     174                // deleted decls should never be used, so don't print them
     175                if ( functionDecl->isDeleted && genC ) return;
    174176                extension( functionDecl );
    175177                genAttributes( functionDecl->get_attributes() );
     
    185187                        functionDecl->get_statements()->accept( *visitor );
    186188                } // if
     189                if ( functionDecl->isDeleted ) {
     190                        output << " = void";
     191                }
    187192        }
    188193
    189194        void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
     195                // deleted decls should never be used, so don't print them
     196                if ( objectDecl->isDeleted && genC ) return;
    190197                if (objectDecl->get_name().empty() && genC ) {
    191198                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
     
    206213                        objectDecl->get_init()->accept( *visitor );
    207214                } // if
     215                if ( objectDecl->isDeleted ) {
     216                        output << " = void";
     217                }
    208218
    209219                if ( objectDecl->get_bitfieldWidth() ) {
     
    827837                expr->expr->accept( *visitor );
    828838        }
     839
     840        void CodeGenerator::postvisit( GenericExpr * expr ) {
     841                assertf( ! genC, "C11 _Generic expressions should not reach code generation." );
     842                output << "_Generic(";
     843                expr->control->accept( *visitor );
     844                output << ", ";
     845                unsigned int numAssocs = expr->associations.size();
     846                unsigned int i = 0;
     847                for ( GenericExpr::Association & assoc : expr->associations ) {
     848                        if (assoc.isDefault) {
     849                                output << "default: ";
     850                        } else {
     851                                output << genType( assoc.type, "", pretty, genC ) << ": ";
     852                        }
     853                        assoc.expr->accept( *visitor );
     854                        if ( i+1 != numAssocs ) {
     855                                output << ", ";
     856                        }
     857                        i++;
     858                }
     859                output << ")";
     860        }
     861
    829862
    830863        // *** Statements
  • src/CodeGen/CodeGenerator.h

    r6b4cdd3 rae32d96  
    9494                void postvisit( ConstructorExpr * );
    9595                void postvisit( DeletedExpr * );
     96                void postvisit( GenericExpr * );
    9697
    9798                //*** Statements
  • src/Common/PassVisitor.h

    r6b4cdd3 rae32d96  
    125125        virtual void visit( InitExpr *  initExpr ) override final;
    126126        virtual void visit( DeletedExpr *  delExpr ) override final;
     127        virtual void visit( GenericExpr * genExpr ) override final;
    127128
    128129        virtual void visit( VoidType * basicType ) override final;
     
    223224        virtual Expression * mutate( InitExpr *  initExpr ) override final;
    224225        virtual Expression * mutate( DeletedExpr *  delExpr ) override final;
     226        virtual Expression * mutate( GenericExpr * genExpr ) override final;
    225227
    226228        virtual Type * mutate( VoidType * basicType ) override final;
     
    311313        void indexerAddUnionFwd ( UnionDecl                 * node  ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
    312314        void indexerAddTrait    ( TraitDecl                 * node  ) { indexer_impl_addTrait    ( pass, 0, node ); }
    313         void indexerAddWith     ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith     ( pass, 0, exprs, withStmt ); }
     315        void indexerAddWith     ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith( pass, 0, exprs, withStmt ); }
    314316
    315317
  • src/Common/PassVisitor.impl.h

    r6b4cdd3 rae32d96  
    20732073
    20742074//--------------------------------------------------------------------------
     2075// GenericExpr
     2076template< typename pass_type >
     2077void PassVisitor< pass_type >::visit( GenericExpr * node ) {
     2078        VISIT_START( node );
     2079
     2080        indexerScopedAccept( node->result, *this );
     2081        maybeAccept_impl( node->control, *this );
     2082        for ( GenericExpr::Association & assoc : node->associations ) {
     2083                indexerScopedAccept( assoc.type, *this );
     2084                maybeAccept_impl( assoc.expr, *this );
     2085        }
     2086
     2087        VISIT_END( node );
     2088}
     2089
     2090template< typename pass_type >
     2091Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) {
     2092        MUTATE_START( node );
     2093
     2094        indexerScopedMutate( node->env, *this );
     2095        indexerScopedMutate( node->result, *this );
     2096        maybeMutate_impl( node->control, *this );
     2097        for ( GenericExpr::Association & assoc : node->associations ) {
     2098                indexerScopedMutate( assoc.type, *this );
     2099                maybeMutate_impl( assoc.expr, *this );
     2100        }
     2101
     2102        MUTATE_END( Expression, node );
     2103}
     2104
     2105//--------------------------------------------------------------------------
    20752106// VoidType
    20762107template< typename pass_type >
  • src/Parser/DeclarationNode.cc

    r6b4cdd3 rae32d96  
    10671067                        SemanticError( this, "invalid function specifier for " );
    10681068                } // if
    1069                 return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1069                bool isDelete = initializer && initializer->get_isDelete();
     1070                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1071                if ( isDelete ) {
     1072                        DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
     1073                        dwt->isDeleted = true;
     1074                }
     1075                return decl;
    10701076        } // if
    10711077
  • src/Parser/InitializerNode.cc

    r6b4cdd3 rae32d96  
    2727
    2828InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
    29                 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
     29                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
    3030        if ( aggrp )
    3131                kids = dynamic_cast< InitializerNode * >( get_next() );
     
    3636
    3737InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
    38                 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
     38                : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
    3939        if ( init )
    4040                set_last( init );
     
    4646                set_next( nullptr );
    4747} // InitializerNode::InitializerNode
     48
     49InitializerNode::InitializerNode( bool isDelete ) : expr( nullptr ), aggregate( false ), designator( nullptr ), kids( nullptr ), maybeConstructed( false ), isDelete( isDelete ) {}
    4850
    4951InitializerNode::~InitializerNode() {
     
    8486
    8587Initializer * InitializerNode::build() const {
     88        assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
    8689        if ( aggregate ) {
    8790                // steal designators from children
  • src/Parser/ParseNode.h

    r6b4cdd3 rae32d96  
    8787        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
    8888        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
     89        InitializerNode( bool isDelete );
    8990        ~InitializerNode();
    9091        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
     
    9798        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
    9899        bool get_maybeConstructed() const { return maybeConstructed; }
     100
     101        bool get_isDelete() const { return isDelete; }
    99102
    100103        InitializerNode * next_init() const { return kids; }
     
    110113        InitializerNode * kids;
    111114        bool maybeConstructed;
     115        bool isDelete;
    112116}; // InitializerNode
    113117
  • src/Parser/TypeData.cc

    r6b4cdd3 rae32d96  
    6565          case Aggregate:
    6666                // aggregate = new Aggregate_t;
     67                aggregate.kind = DeclarationNode::NoAggregate;
    6768                aggregate.name = nullptr;
    6869                aggregate.params = nullptr;
     
    7071                aggregate.fields = nullptr;
    7172                aggregate.body = false;
     73                aggregate.tagged = false;
     74                aggregate.parent = nullptr;
    7275                break;
    7376          case AggregateInst:
     
    198201                break;
    199202          case Aggregate:
     203                newtype->aggregate.kind = aggregate.kind;
    200204                newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
    201205                newtype->aggregate.params = maybeClone( aggregate.params );
    202206                newtype->aggregate.actuals = maybeClone( aggregate.actuals );
    203207                newtype->aggregate.fields = maybeClone( aggregate.fields );
    204                 newtype->aggregate.kind = aggregate.kind;
    205208                newtype->aggregate.body = aggregate.body;
    206209                newtype->aggregate.tagged = aggregate.tagged;
  • src/Parser/parser.yy

    r6b4cdd3 rae32d96  
    175175        bool flag;
    176176        CatchStmt::Kind catch_kind;
     177        GenericExpr * genexpr;
    177178}
    178179
     
    259260%type<flag> asm_volatile_opt
    260261%type<en> handler_predicate_opt
     262%type<genexpr> generic_association generic_assoc_list
    261263
    262264// statements
     
    501503                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    502504        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
    503                 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
     505                {
     506                        // add the missing control expression to the GenericExpr and return it
     507                        $5->control = maybeMoveBuild<Expression>( $3 );
     508                        $$ = new ExpressionNode( $5 );
     509                }
    504510        ;
    505511
    506512generic_assoc_list:                                                                             // C11
    507         | generic_association
     513        generic_association
    508514        | generic_assoc_list ',' generic_association
     515                {
     516                        // steal the association node from the singleton and delete the wrapper
     517                        $1->associations.splice($1->associations.end(), $3->associations);
     518                        delete $3;
     519                        $$ = $1;
     520                }
    509521        ;
    510522
    511523generic_association:                                                                    // C11
    512524        type_no_function ':' assignment_expression
     525                {
     526                        // create a GenericExpr wrapper with one association pair
     527                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>($3) } } );
     528                }
    513529        | DEFAULT ':' assignment_expression
     530                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>($3) } } ); }
    514531        ;
    515532
     
    20842101                { $$ = $2; }
    20852102        | '=' VOID
    2086                 { $$ = nullptr; }
     2103                { $$ = new InitializerNode( true ); }
    20872104        | ATassign initializer
    20882105                { $$ = $2->set_maybeConstructed( false ); }
  • src/ResolvExpr/AlternativeFinder.cc

    r6b4cdd3 rae32d96  
    9797                void postvisit( InitExpr * initExpr );
    9898                void postvisit( DeletedExpr * delExpr );
     99                void postvisit( GenericExpr * genExpr );
    99100
    100101                /// Adds alternatives for anonymous members
     
    17561757                assertf( false, "AlternativeFinder should never see a DeletedExpr." );
    17571758        }
     1759
     1760        void AlternativeFinder::Finder::postvisit( GenericExpr * ) {
     1761                assertf( false, "_Generic is not yet supported." );
     1762        }
    17581763} // namespace ResolvExpr
    17591764
  • src/SymTab/Indexer.cc

    r6b4cdd3 rae32d96  
    148148                for ( auto decl : copy ) {
    149149                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
    150                                 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
     150                                std::list< DeclarationWithType * > & params = function->type->parameters;
    151151                                assert( ! params.empty() );
    152152                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
     
    170170                                bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
    171171                                bool isUserDefinedFunc = ball.isUserDefinedFunc;
    172                                 bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
     172                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->linkage == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
    173173                                bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
    174174                                bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
     
    471471        void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
    472472                // default handling of conflicts is to raise an error
    473                 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr );
     473                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
    474474        }
    475475
  • src/SymTab/Mangler.cc

    r6b4cdd3 rae32d96  
    171171                                        "w",    // SignedInt128
    172172                                        "Uw",   // UnsignedInt128
    173                                         "a",   // Float80
    174                                         "A",   // Float128
     173                                        "x",   // Float80
     174                                        "y",   // Float128
    175175                                };
    176176                                static_assert(
     
    225225                                GuardValue( inFunctionType );
    226226                                inFunctionType = true;
    227                                 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
     227                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
    228228                                acceptAll( returnTypes, *visitor );
    229229                                mangleName << "_";
    230                                 std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
     230                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
    231231                                acceptAll( paramTypes, *visitor );
    232232                                mangleName << "_";
     
    236236                                printQualifiers( refType );
    237237
    238                                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
     238                                mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
    239239
    240240                                if ( mangleGenericParams ) {
    241                                         std::list< Expression* >& params = refType->get_parameters();
     241                                        std::list< Expression* >& params = refType->parameters;
    242242                                        if ( ! params.empty() ) {
    243243                                                mangleName << "_";
    244244                                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
    245245                                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    246                                                         assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
    247                                                         maybeAccept( paramType->get_type(), *visitor );
     246                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
     247                                                        maybeAccept( paramType->type, *visitor );
    248248                                                }
    249249                                                mangleName << "_";
  • src/SynTree/Declaration.cc

    r6b4cdd3 rae32d96  
    104104}
    105105
     106
    106107// Local Variables: //
    107108// tab-width: 4 //
  • src/SynTree/Declaration.h

    r6b4cdd3 rae32d96  
    8484        Expression *asmName;
    8585        std::list< Attribute * > attributes;
     86        bool isDeleted = false;
    8687
    8788        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
  • src/SynTree/Expression.cc

    r6b4cdd3 rae32d96  
    748748}
    749749
     750GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
     751GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
     752GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
     753GenericExpr::Association::~Association() {
     754        delete type;
     755        delete expr;
     756}
     757
     758GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
     759GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
     760}
     761GenericExpr::~GenericExpr() {
     762        delete control;
     763}
     764
     765void GenericExpr::print( std::ostream & os, Indenter indent ) const {
     766        os << "C11 _Generic Expression" << std::endl << indent+1;
     767        control->print( os, indent+1 );
     768        os << std::endl << indent+1 << "... with associations: " << std::endl;
     769        for ( const Association & assoc : associations ) {
     770                os << indent+1;
     771                if (assoc.isDefault) {
     772                        os << "... default: ";
     773                        assoc.expr->print( os, indent+1 );
     774                } else {
     775                        os << "... type: ";
     776                        assoc.type->print( os, indent+1 );
     777                        os << std::endl << indent+1 << "... expression: ";
     778                        assoc.expr->print( os, indent+1 );
     779                        os << std::endl;
     780                }
     781                os << std::endl;
     782        }
     783}
    750784
    751785// Local Variables: //
  • src/SynTree/Expression.h

    r6b4cdd3 rae32d96  
    865865};
    866866
     867/// C11 _Generic expression
     868class GenericExpr : public Expression {
     869public:
     870        struct Association {
     871                Type * type = nullptr;
     872                Expression * expr = nullptr;
     873                bool isDefault = false;
     874
     875                Association( Type * type, Expression * expr );
     876                Association( Expression * expr );
     877                Association( const Association & other );
     878                Association & operator=( const Association & other ) = delete; // at the moment this isn't used, and I don't want to implement it
     879                ~Association();
     880        };
     881
     882        Expression * control;
     883        std::list<Association> associations;
     884
     885        GenericExpr( Expression * control, const std::list<Association> & assoc );
     886        GenericExpr( const GenericExpr & other );
     887        virtual ~GenericExpr();
     888
     889        virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
     890        virtual void accept( Visitor & v ) { v.visit( this ); }
     891        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     892        virtual void print( std::ostream & os, Indenter indent = {} ) const;
     893};
     894
    867895// Local Variables: //
    868896// tab-width: 4 //
  • src/SynTree/Mutator.h

    r6b4cdd3 rae32d96  
    9393        virtual Expression * mutate( InitExpr  * initExpr ) = 0;
    9494        virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
     95        virtual Expression * mutate( GenericExpr * genExpr ) = 0;
    9596
    9697        virtual Type * mutate( VoidType * basicType ) = 0;
  • src/SynTree/SynTree.h

    r6b4cdd3 rae32d96  
    101101class InitExpr;
    102102class DeletedExpr;
     103class GenericExpr;
    103104
    104105class Type;
  • src/SynTree/Visitor.h

    r6b4cdd3 rae32d96  
    9595        virtual void visit( InitExpr *  initExpr ) = 0;
    9696        virtual void visit( DeletedExpr * delExpr ) = 0;
     97        virtual void visit( GenericExpr * genExpr ) = 0;
    9798
    9899        virtual void visit( VoidType * basicType ) = 0;
Note: See TracChangeset for help on using the changeset viewer.