Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/CodeGen/CodeGenerator.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -287,11 +287,14 @@ void CodeGenerator::postvisit( TypeDecl * typeDecl ) { assertf( ! genC, "TypeDecls should not reach code generation." ); - output << typeDecl->genTypeString() << " " << typeDecl->get_name(); - if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) { - output << " | sized(" << typeDecl->get_name() << ")"; - } - if ( ! typeDecl->get_assertions().empty() ) { + output << typeDecl->genTypeString() << " " << typeDecl->name; + if ( typeDecl->sized ) { + output << " | sized(" << typeDecl->name << ")"; + } + if ( ! typeDecl->assertions.empty() ) { output << " | { "; - genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() ); + for ( DeclarationWithType * assert : typeDecl->assertions ) { + assert->accept( *visitor ); + output << "; "; + } output << " }"; } @@ -443,11 +446,11 @@ void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) { extension( untypedExpr ); - if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) { + if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) { OperatorInfo opInfo; - if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { - std::list< Expression* >::iterator arg = untypedExpr->get_args().begin(); + if ( operatorLookup( nameExpr->name, opInfo ) ) { + std::list< Expression* >::iterator arg = untypedExpr->args.begin(); switch ( opInfo.type ) { case OT_INDEX: - assert( untypedExpr->get_args().size() == 2 ); + assert( untypedExpr->args.size() == 2 ); (*arg++)->accept( *visitor ); output << "["; @@ -461,5 +464,5 @@ case OT_CTOR: case OT_DTOR: - if ( untypedExpr->get_args().size() == 1 ) { + if ( untypedExpr->args.size() == 1 ) { // the expression fed into a single parameter constructor or destructor may contain side // effects, so must still output this expression @@ -480,5 +483,5 @@ (*arg++)->accept( *visitor ); output << opInfo.symbol << "{ "; - genCommaList( arg, untypedExpr->get_args().end() ); + genCommaList( arg, untypedExpr->args.end() ); output << "}) /* " << opInfo.inputName << " */"; } // if @@ -488,5 +491,5 @@ case OT_PREFIXASSIGN: case OT_LABELADDRESS: - assert( untypedExpr->get_args().size() == 1 ); + assert( untypedExpr->args.size() == 1 ); output << "("; output << opInfo.symbol; @@ -497,5 +500,5 @@ case OT_POSTFIX: case OT_POSTFIXASSIGN: - assert( untypedExpr->get_args().size() == 1 ); + assert( untypedExpr->args.size() == 1 ); (*arg)->accept( *visitor ); output << opInfo.symbol; @@ -504,5 +507,5 @@ case OT_INFIX: case OT_INFIXASSIGN: - assert( untypedExpr->get_args().size() == 2 ); + assert( untypedExpr->args.size() == 2 ); output << "("; (*arg++)->accept( *visitor ); @@ -517,20 +520,14 @@ } // switch } else { - if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2 - assert( untypedExpr->get_args().size() == 2 ); - (*untypedExpr->get_args().begin())->accept( *visitor ); - output << " ... "; - (*--untypedExpr->get_args().end())->accept( *visitor ); - } else { // builtin routines - nameExpr->accept( *visitor ); - output << "("; - genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); - output << ")"; - } // if + // builtin routines + nameExpr->accept( *visitor ); + output << "("; + genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() ); + output << ")"; } // if } else { - untypedExpr->get_function()->accept( *visitor ); + untypedExpr->function->accept( *visitor ); output << "("; - genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); + genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() ); output << ")"; } // if @@ -538,7 +535,7 @@ void CodeGenerator::postvisit( RangeExpr * rangeExpr ) { - rangeExpr->get_low()->accept( *visitor ); + rangeExpr->low->accept( *visitor ); output << " ... "; - rangeExpr->get_high()->accept( *visitor ); + rangeExpr->high->accept( *visitor ); } @@ -546,7 +543,10 @@ extension( nameExpr ); OperatorInfo opInfo; - if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { - assert( opInfo.type == OT_CONSTANT ); - output << opInfo.symbol; + if ( operatorLookup( nameExpr->name, opInfo ) ) { + if ( opInfo.type == OT_CONSTANT ) { + output << opInfo.symbol; + } else { + output << opInfo.outputName; + } } else { output << nameExpr->get_name(); @@ -885,4 +885,6 @@ void CodeGenerator::postvisit( CaseStmt * caseStmt ) { + updateLocation( caseStmt ); + output << indent; if ( caseStmt->isDefault()) { output << "default"; @@ -947,4 +949,67 @@ output << ";"; } + void CodeGenerator::postvisit( CatchStmt * stmt ) { + assertf( ! genC, "Catch statements should not reach code generation." ); + + output << ((stmt->get_kind() == CatchStmt::Terminate) ? + "catch" : "catchResume"); + output << "( "; + stmt->decl->accept( *visitor ); + output << " ) "; + + if( stmt->cond ) { + output << "if/when(?) ("; + stmt->cond->accept( *visitor ); + output << ") "; + } + stmt->body->accept( *visitor ); + } + + void CodeGenerator::postvisit( WaitForStmt * stmt ) { + assertf( ! genC, "Waitfor statements should not reach code generation." ); + + bool first = true; + for( auto & clause : stmt->clauses ) { + if(first) { output << "or "; first = false; } + if( clause.condition ) { + output << "when("; + stmt->timeout.condition->accept( *visitor ); + output << ") "; + } + output << "waitfor("; + clause.target.function->accept( *visitor ); + for( Expression * expr : clause.target.arguments ) { + output << ","; + expr->accept( *visitor ); + } + output << ") "; + clause.statement->accept( *visitor ); + } + + if( stmt->timeout.statement ) { + output << "or "; + if( stmt->timeout.condition ) { + output << "when("; + stmt->timeout.condition->accept( *visitor ); + output << ") "; + } + output << "timeout("; + stmt->timeout.time->accept( *visitor ); + output << ") "; + stmt->timeout.statement->accept( *visitor ); + } + + if( stmt->orelse.statement ) { + output << "or "; + if( stmt->orelse.condition ) { + output << "when("; + stmt->orelse.condition->accept( *visitor ); + output << ")"; + } + output << "else "; + stmt->orelse.statement->accept( *visitor ); + } + } + void CodeGenerator::postvisit( WhileStmt * whileStmt ) { @@ -1025,4 +1090,16 @@ } } // namespace CodeGen + + +unsigned Indenter::tabsize = 2; + +std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) { + if ( node ) { + node->print( out ); + } else { + out << "nullptr"; + } + return out; +} // Local Variables: // Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/CodeGen/CodeGenerator.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -100,4 +100,6 @@ void postvisit( ReturnStmt * ); void postvisit( ThrowStmt * ); + void postvisit( CatchStmt * ); + void postvisit( WaitForStmt * ); void postvisit( WhileStmt * ); void postvisit( ForStmt * ); Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/CodeGen/FixNames.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -66,9 +66,9 @@ ); - mainDecl->get_functionType()->get_parameters().push_back( + main_type->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); - mainDecl->get_functionType()->get_parameters().push_back( + main_type->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ), Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/CodeGen/GenType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -210,9 +210,9 @@ std::string GenType::handleGeneric( ReferenceToType * refType ) { - if ( ! refType->get_parameters().empty() ) { + if ( ! refType->parameters.empty() ) { std::ostringstream os; PassVisitor cg( os, pretty, genC, lineMarks ); os << "("; - cg.pass.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() ); + cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() ); os << ") "; return os.str(); Index: src/Common/Indenter.h =================================================================== --- src/Common/Indenter.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Common/Indenter.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -18,7 +18,9 @@ struct Indenter { - Indenter( unsigned int amt = 2 ) : amt( amt ) {} - unsigned int amt = 2; // amount 1 level increases indent by (i.e. how much to increase by in operator++) - unsigned int indent = 0; + static unsigned tabsize; + + Indenter( unsigned int amt = tabsize, unsigned int indent = 0 ) : amt( amt ), indent( indent ) {} + unsigned int amt; // amount 1 level increases indent by (i.e. how much to increase by in operator++) + unsigned int indent; Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; } @@ -30,5 +32,5 @@ }; -inline std::ostream & operator<<( std::ostream & out, Indenter & indent ) { +inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) { return out << std::string(indent.indent, ' '); } Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Common/PassVisitor.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -4,4 +4,6 @@ #include + +#include "Common/utility.h" #include "SynTree/Mutator.h" @@ -10,4 +12,5 @@ #include "SymTab/Indexer.h" +#include "SynTree/Attribute.h" #include "SynTree/Initializer.h" #include "SynTree/Statement.h" @@ -53,185 +56,195 @@ pass_type pass; - virtual void visit( ObjectDecl *objectDecl ) override final; - virtual void visit( FunctionDecl *functionDecl ) override final; - virtual void visit( StructDecl *aggregateDecl ) override final; - virtual void visit( UnionDecl *aggregateDecl ) override final; - virtual void visit( EnumDecl *aggregateDecl ) override final; - virtual void visit( TraitDecl *aggregateDecl ) override final; - virtual void visit( TypeDecl *typeDecl ) override final; - virtual void visit( TypedefDecl *typeDecl ) override final; - virtual void visit( AsmDecl *asmDecl ) override final; - - virtual void visit( CompoundStmt *compoundStmt ) override final; - virtual void visit( ExprStmt *exprStmt ) override final; - virtual void visit( AsmStmt *asmStmt ) override final; - virtual void visit( IfStmt *ifStmt ) override final; - virtual void visit( WhileStmt *whileStmt ) override final; - virtual void visit( ForStmt *forStmt ) override final; - virtual void visit( SwitchStmt *switchStmt ) override final; - virtual void visit( CaseStmt *caseStmt ) override final; - virtual void visit( BranchStmt *branchStmt ) override final; - virtual void visit( ReturnStmt *returnStmt ) override final; - virtual void visit( ThrowStmt *throwStmt ) override final; - virtual void visit( TryStmt *tryStmt ) override final; - virtual void visit( CatchStmt *catchStmt ) override final; - virtual void visit( FinallyStmt *finallyStmt ) override final; - virtual void visit( WaitForStmt *waitforStmt ) override final; - virtual void visit( NullStmt *nullStmt ) override final; - virtual void visit( DeclStmt *declStmt ) override final; - virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; - - virtual void visit( ApplicationExpr *applicationExpr ) override final; - virtual void visit( UntypedExpr *untypedExpr ) override final; - virtual void visit( NameExpr *nameExpr ) override final; - virtual void visit( CastExpr *castExpr ) override final; - virtual void visit( VirtualCastExpr *castExpr ) override final; - virtual void visit( AddressExpr *addressExpr ) override final; - virtual void visit( LabelAddressExpr *labAddressExpr ) override final; - virtual void visit( UntypedMemberExpr *memberExpr ) override final; - virtual void visit( MemberExpr *memberExpr ) override final; - virtual void visit( VariableExpr *variableExpr ) override final; - virtual void visit( ConstantExpr *constantExpr ) override final; - virtual void visit( SizeofExpr *sizeofExpr ) override final; - virtual void visit( AlignofExpr *alignofExpr ) override final; - virtual void visit( UntypedOffsetofExpr *offsetofExpr ) override final; - virtual void visit( OffsetofExpr *offsetofExpr ) override final; - virtual void visit( OffsetPackExpr *offsetPackExpr ) override final; - virtual void visit( AttrExpr *attrExpr ) override final; - virtual void visit( LogicalExpr *logicalExpr ) override final; - virtual void visit( ConditionalExpr *conditionalExpr ) override final; - virtual void visit( CommaExpr *commaExpr ) override final; - virtual void visit( TypeExpr *typeExpr ) override final; - virtual void visit( AsmExpr *asmExpr ) override final; - virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; - virtual void visit( ConstructorExpr * ctorExpr ) override final; - virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; - virtual void visit( RangeExpr *rangeExpr ) override final; - virtual void visit( UntypedTupleExpr *tupleExpr ) override final; - virtual void visit( TupleExpr *tupleExpr ) override final; - virtual void visit( TupleIndexExpr *tupleExpr ) override final; - virtual void visit( TupleAssignExpr *assignExpr ) override final; - virtual void visit( StmtExpr * stmtExpr ) override final; - virtual void visit( UniqueExpr * uniqueExpr ) override final; - - virtual void visit( VoidType *basicType ) override final; - virtual void visit( BasicType *basicType ) override final; - virtual void visit( PointerType *pointerType ) override final; - virtual void visit( ArrayType *arrayType ) override final; - virtual void visit( ReferenceType *referenceType ) override final; - virtual void visit( FunctionType *functionType ) override final; - virtual void visit( StructInstType *aggregateUseType ) override final; - virtual void visit( UnionInstType *aggregateUseType ) override final; - virtual void visit( EnumInstType *aggregateUseType ) override final; - virtual void visit( TraitInstType *aggregateUseType ) override final; - virtual void visit( TypeInstType *aggregateUseType ) override final; - virtual void visit( TupleType *tupleType ) override final; - virtual void visit( TypeofType *typeofType ) override final; - virtual void visit( AttrType *attrType ) override final; - virtual void visit( VarArgsType *varArgsType ) override final; - virtual void visit( ZeroType *zeroType ) override final; - virtual void visit( OneType *oneType ) override final; - - virtual void visit( Designation *designation ) override final; - virtual void visit( SingleInit *singleInit ) override final; - virtual void visit( ListInit *listInit ) override final; - virtual void visit( ConstructorInit *ctorInit ) override final; - - virtual void visit( Subrange *subrange ) override final; - - virtual void visit( Constant *constant ) override final; - - virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final; - virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final; - virtual Declaration* mutate( StructDecl *aggregateDecl ) override final; - virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final; - virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final; - virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final; - virtual Declaration* mutate( TypeDecl *typeDecl ) override final; - virtual Declaration* mutate( TypedefDecl *typeDecl ) override final; - virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final; - - virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final; - virtual Statement* mutate( ExprStmt *exprStmt ) override final; - virtual Statement* mutate( AsmStmt *asmStmt ) override final; - virtual Statement* mutate( IfStmt *ifStmt ) override final; - virtual Statement* mutate( WhileStmt *whileStmt ) override final; - virtual Statement* mutate( ForStmt *forStmt ) override final; - virtual Statement* mutate( SwitchStmt *switchStmt ) override final; - virtual Statement* mutate( CaseStmt *caseStmt ) override final; - virtual Statement* mutate( BranchStmt *branchStmt ) override final; - virtual Statement* mutate( ReturnStmt *returnStmt ) override final; - virtual Statement* mutate( ThrowStmt *throwStmt ) override final; - virtual Statement* mutate( TryStmt *tryStmt ) override final; - virtual Statement* mutate( CatchStmt *catchStmt ) override final; - virtual Statement* mutate( FinallyStmt *finallyStmt ) override final; - virtual Statement* mutate( WaitForStmt *waitforStmt ) override final; - virtual NullStmt* mutate( NullStmt *nullStmt ) override final; - virtual Statement* mutate( DeclStmt *declStmt ) override final; - virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; - - virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final; - virtual Expression* mutate( UntypedExpr *untypedExpr ) override final; - virtual Expression* mutate( NameExpr *nameExpr ) override final; - virtual Expression* mutate( AddressExpr *castExpr ) override final; - virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final; - virtual Expression* mutate( CastExpr *castExpr ) override final; - virtual Expression* mutate( VirtualCastExpr *castExpr ) override final; - virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final; - virtual Expression* mutate( MemberExpr *memberExpr ) override final; - virtual Expression* mutate( VariableExpr *variableExpr ) override final; - virtual Expression* mutate( ConstantExpr *constantExpr ) override final; - virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final; - virtual Expression* mutate( AlignofExpr *alignofExpr ) override final; - virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final; - virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final; - virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final; - virtual Expression* mutate( AttrExpr *attrExpr ) override final; - virtual Expression* mutate( LogicalExpr *logicalExpr ) override final; - virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final; - virtual Expression* mutate( CommaExpr *commaExpr ) override final; - virtual Expression* mutate( TypeExpr *typeExpr ) override final; - virtual Expression* mutate( AsmExpr *asmExpr ) override final; - virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; - virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; - virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; - virtual Expression* mutate( RangeExpr *rangeExpr ) override final; - virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final; - virtual Expression* mutate( StmtExpr * stmtExpr ) override final; - virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final; - - virtual Type* mutate( VoidType *basicType ) override final; - virtual Type* mutate( BasicType *basicType ) override final; - virtual Type* mutate( PointerType *pointerType ) override final; - virtual Type* mutate( ArrayType *arrayType ) override final; - virtual Type* mutate( ReferenceType *referenceType ) override final; - virtual Type* mutate( FunctionType *functionType ) override final; - virtual Type* mutate( StructInstType *aggregateUseType ) override final; - virtual Type* mutate( UnionInstType *aggregateUseType ) override final; - virtual Type* mutate( EnumInstType *aggregateUseType ) override final; - virtual Type* mutate( TraitInstType *aggregateUseType ) override final; - virtual Type* mutate( TypeInstType *aggregateUseType ) override final; - virtual Type* mutate( TupleType *tupleType ) override final; - virtual Type* mutate( TypeofType *typeofType ) override final; - virtual Type* mutate( AttrType *attrType ) override final; - virtual Type* mutate( VarArgsType *varArgsType ) override final; - virtual Type* mutate( ZeroType *zeroType ) override final; - virtual Type* mutate( OneType *oneType ) override final; - - virtual Designation* mutate( Designation *designation ) override final; - virtual Initializer* mutate( SingleInit *singleInit ) override final; - virtual Initializer* mutate( ListInit *listInit ) override final; - virtual Initializer* mutate( ConstructorInit *ctorInit ) override final; - - virtual Subrange *mutate( Subrange *subrange ) override final; - - virtual Constant *mutate( Constant *constant ) override final; + virtual void visit( ObjectDecl * objectDecl ) override final; + virtual void visit( FunctionDecl * functionDecl ) override final; + virtual void visit( StructDecl * aggregateDecl ) override final; + virtual void visit( UnionDecl * aggregateDecl ) override final; + virtual void visit( EnumDecl * aggregateDecl ) override final; + virtual void visit( TraitDecl * aggregateDecl ) override final; + virtual void visit( TypeDecl * typeDecl ) override final; + virtual void visit( TypedefDecl * typeDecl ) override final; + virtual void visit( AsmDecl * asmDecl ) override final; + + virtual void visit( CompoundStmt * compoundStmt ) override final; + virtual void visit( ExprStmt * exprStmt ) override final; + virtual void visit( AsmStmt * asmStmt ) override final; + virtual void visit( IfStmt * ifStmt ) override final; + virtual void visit( WhileStmt * whileStmt ) override final; + virtual void visit( ForStmt * forStmt ) override final; + virtual void visit( SwitchStmt * switchStmt ) override final; + virtual void visit( CaseStmt * caseStmt ) override final; + virtual void visit( BranchStmt * branchStmt ) override final; + virtual void visit( ReturnStmt * returnStmt ) override final; + virtual void visit( ThrowStmt * throwStmt ) override final; + virtual void visit( TryStmt * tryStmt ) override final; + virtual void visit( CatchStmt * catchStmt ) override final; + virtual void visit( FinallyStmt * finallyStmt ) override final; + virtual void visit( WaitForStmt * waitforStmt ) override final; + virtual void visit( NullStmt * nullStmt ) override final; + virtual void visit( DeclStmt * declStmt ) override final; + virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final; + + virtual void visit( ApplicationExpr * applicationExpr ) override final; + virtual void visit( UntypedExpr * untypedExpr ) override final; + virtual void visit( NameExpr * nameExpr ) override final; + virtual void visit( CastExpr * castExpr ) override final; + virtual void visit( VirtualCastExpr * castExpr ) override final; + virtual void visit( AddressExpr * addressExpr ) override final; + virtual void visit( LabelAddressExpr * labAddressExpr ) override final; + virtual void visit( UntypedMemberExpr * memberExpr ) override final; + virtual void visit( MemberExpr * memberExpr ) override final; + virtual void visit( VariableExpr * variableExpr ) override final; + virtual void visit( ConstantExpr * constantExpr ) override final; + virtual void visit( SizeofExpr * sizeofExpr ) override final; + virtual void visit( AlignofExpr * alignofExpr ) override final; + virtual void visit( UntypedOffsetofExpr * offsetofExpr ) override final; + virtual void visit( OffsetofExpr * offsetofExpr ) override final; + virtual void visit( OffsetPackExpr * offsetPackExpr ) override final; + virtual void visit( AttrExpr * attrExpr ) override final; + virtual void visit( LogicalExpr * logicalExpr ) override final; + virtual void visit( ConditionalExpr * conditionalExpr ) override final; + virtual void visit( CommaExpr * commaExpr ) override final; + virtual void visit( TypeExpr * typeExpr ) override final; + virtual void visit( AsmExpr * asmExpr ) override final; + virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override final; + virtual void visit( ConstructorExpr * ctorExpr ) override final; + virtual void visit( CompoundLiteralExpr * compLitExpr ) override final; + virtual void visit( RangeExpr * rangeExpr ) override final; + virtual void visit( UntypedTupleExpr * tupleExpr ) override final; + virtual void visit( TupleExpr * tupleExpr ) override final; + virtual void visit( TupleIndexExpr * tupleExpr ) override final; + virtual void visit( TupleAssignExpr * assignExpr ) override final; + virtual void visit( StmtExpr * stmtExpr ) override final; + virtual void visit( UniqueExpr * uniqueExpr ) override final; + + virtual void visit( VoidType * basicType ) override final; + virtual void visit( BasicType * basicType ) override final; + virtual void visit( PointerType * pointerType ) override final; + virtual void visit( ArrayType * arrayType ) override final; + virtual void visit( ReferenceType * referenceType ) override final; + virtual void visit( FunctionType * functionType ) override final; + virtual void visit( StructInstType * aggregateUseType ) override final; + virtual void visit( UnionInstType * aggregateUseType ) override final; + virtual void visit( EnumInstType * aggregateUseType ) override final; + virtual void visit( TraitInstType * aggregateUseType ) override final; + virtual void visit( TypeInstType * aggregateUseType ) override final; + virtual void visit( TupleType * tupleType ) override final; + virtual void visit( TypeofType * typeofType ) override final; + virtual void visit( AttrType * attrType ) override final; + virtual void visit( VarArgsType * varArgsType ) override final; + virtual void visit( ZeroType * zeroType ) override final; + virtual void visit( OneType * oneType ) override final; + + virtual void visit( Designation * designation ) override final; + virtual void visit( SingleInit * singleInit ) override final; + virtual void visit( ListInit * listInit ) override final; + virtual void visit( ConstructorInit * ctorInit ) override final; + + virtual void visit( Subrange * subrange ) override final; + + virtual void visit( Constant * constant ) override final; + + virtual void visit( Attribute * attribute ) override final; + + virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final; + virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) override final; + virtual Declaration * mutate( StructDecl * aggregateDecl ) override final; + virtual Declaration * mutate( UnionDecl * aggregateDecl ) override final; + virtual Declaration * mutate( EnumDecl * aggregateDecl ) override final; + virtual Declaration * mutate( TraitDecl * aggregateDecl ) override final; + virtual Declaration * mutate( TypeDecl * typeDecl ) override final; + virtual Declaration * mutate( TypedefDecl * typeDecl ) override final; + virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final; + + virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final; + virtual Statement * mutate( ExprStmt * exprStmt ) override final; + virtual Statement * mutate( AsmStmt * asmStmt ) override final; + virtual Statement * mutate( IfStmt * ifStmt ) override final; + virtual Statement * mutate( WhileStmt * whileStmt ) override final; + virtual Statement * mutate( ForStmt * forStmt ) override final; + virtual Statement * mutate( SwitchStmt * switchStmt ) override final; + virtual Statement * mutate( CaseStmt * caseStmt ) override final; + virtual Statement * mutate( BranchStmt * branchStmt ) override final; + virtual Statement * mutate( ReturnStmt * returnStmt ) override final; + virtual Statement * mutate( ThrowStmt * throwStmt ) override final; + virtual Statement * mutate( TryStmt * tryStmt ) override final; + virtual Statement * mutate( CatchStmt * catchStmt ) override final; + virtual Statement * mutate( FinallyStmt * finallyStmt ) override final; + virtual Statement * mutate( WaitForStmt * waitforStmt ) override final; + virtual NullStmt * mutate( NullStmt * nullStmt ) override final; + virtual Statement * mutate( DeclStmt * declStmt ) override final; + virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final; + + virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final; + virtual Expression * mutate( UntypedExpr * untypedExpr ) override final; + virtual Expression * mutate( NameExpr * nameExpr ) override final; + virtual Expression * mutate( AddressExpr * castExpr ) override final; + virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final; + virtual Expression * mutate( CastExpr * castExpr ) override final; + virtual Expression * mutate( VirtualCastExpr * castExpr ) override final; + virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final; + virtual Expression * mutate( MemberExpr * memberExpr ) override final; + virtual Expression * mutate( VariableExpr * variableExpr ) override final; + virtual Expression * mutate( ConstantExpr * constantExpr ) override final; + virtual Expression * mutate( SizeofExpr * sizeofExpr ) override final; + virtual Expression * mutate( AlignofExpr * alignofExpr ) override final; + virtual Expression * mutate( UntypedOffsetofExpr * offsetofExpr ) override final; + virtual Expression * mutate( OffsetofExpr * offsetofExpr ) override final; + virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) override final; + virtual Expression * mutate( AttrExpr * attrExpr ) override final; + virtual Expression * mutate( LogicalExpr * logicalExpr ) override final; + virtual Expression * mutate( ConditionalExpr * conditionalExpr ) override final; + virtual Expression * mutate( CommaExpr * commaExpr ) override final; + virtual Expression * mutate( TypeExpr * typeExpr ) override final; + virtual Expression * mutate( AsmExpr * asmExpr ) override final; + virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override final; + virtual Expression * mutate( ConstructorExpr * ctorExpr ) override final; + virtual Expression * mutate( CompoundLiteralExpr * compLitExpr ) override final; + virtual Expression * mutate( RangeExpr * rangeExpr ) override final; + virtual Expression * mutate( UntypedTupleExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleAssignExpr * assignExpr ) override final; + virtual Expression * mutate( StmtExpr * stmtExpr ) override final; + virtual Expression * mutate( UniqueExpr * uniqueExpr ) override final; + + virtual Type * mutate( VoidType * basicType ) override final; + virtual Type * mutate( BasicType * basicType ) override final; + virtual Type * mutate( PointerType * pointerType ) override final; + virtual Type * mutate( ArrayType * arrayType ) override final; + virtual Type * mutate( ReferenceType * referenceType ) override final; + virtual Type * mutate( FunctionType * functionType ) override final; + virtual Type * mutate( StructInstType * aggregateUseType ) override final; + virtual Type * mutate( UnionInstType * aggregateUseType ) override final; + virtual Type * mutate( EnumInstType * aggregateUseType ) override final; + virtual Type * mutate( TraitInstType * aggregateUseType ) override final; + virtual Type * mutate( TypeInstType * aggregateUseType ) override final; + virtual Type * mutate( TupleType * tupleType ) override final; + virtual Type * mutate( TypeofType * typeofType ) override final; + virtual Type * mutate( AttrType * attrType ) override final; + virtual Type * mutate( VarArgsType * varArgsType ) override final; + virtual Type * mutate( ZeroType * zeroType ) override final; + virtual Type * mutate( OneType * oneType ) override final; + + virtual Designation * mutate( Designation * designation ) override final; + virtual Initializer * mutate( SingleInit * singleInit ) override final; + virtual Initializer * mutate( ListInit * listInit ) override final; + virtual Initializer * mutate( ConstructorInit * ctorInit ) override final; + + virtual Subrange * mutate( Subrange * subrange ) override final; + + virtual Constant * mutate( Constant * constant ) override final; + + virtual Attribute * mutate( Attribute * attribute ) override final; + + virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final; private: template friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor ); template friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor ); + template< typename TreeType, typename pass_t > friend void maybeAccept_impl( TreeType * tree, PassVisitor< pass_t > & visitor ); + template< typename TreeType, typename pass_t > friend void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_t > & mutator ); + template< typename Container, typename pass_t > friend void maybeAccept_impl( Container & container, PassVisitor< pass_t > & visitor ); + template< typename Container, typename pass_t > friend void maybeMutate_impl( Container & container, PassVisitor< pass_t > & mutator ); template void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); } @@ -268,5 +281,6 @@ std::list< Declaration* > * get_afterDecls () { return declsToAddAfter_impl ( pass, 0); } - void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); } + bool get_visit_children () { bool_ref * ptr = visit_children_impl(pass, 0); return ptr ? *ptr : true; } + bool_ref * get_visit_children_ptr() { return visit_children_impl(pass, 0); } void indexerScopeEnter () { indexer_impl_enterScope ( pass, 0 ); } Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Common/PassVisitor.impl.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -2,39 +2,39 @@ // IWYU pragma: private, include "PassVisitor.h" -#define VISIT_START( node ) \ - __attribute__((unused)) \ +#define VISIT_START( node ) \ + __attribute__((unused)) \ + ChildrenGuard children_guard( get_visit_children_ptr() ); \ + __attribute__((unused)) \ guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ - bool visit_children = true; \ - set_visit_children( visit_children ); \ - call_previsit( node ); \ - if( visit_children ) { \ + call_previsit( node ); \ #define VISIT_END( node ) \ - } \ call_postvisit( node ); \ -#define MUTATE_START( node ) \ - __attribute__((unused)) \ +#define MUTATE_START( node ) \ + __attribute__((unused)) \ + ChildrenGuard children_guard( get_visit_children_ptr() ); \ + __attribute__((unused)) \ guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ - bool visit_children = true; \ - set_visit_children( visit_children ); \ - call_premutate( node ); \ - if( visit_children ) { \ + call_premutate( node ); \ #define MUTATE_END( type, node ) \ - } \ return call_postmutate< type * >( node ); \ -#define VISIT_BODY( node ) \ - VISIT_START( node ); \ - Visitor::visit( node ); \ - VISIT_END( node ); \ - - -#define MUTATE_BODY( type, node ) \ - MUTATE_START( node ); \ - Mutator::mutate( node ); \ - MUTATE_END( type, node ); \ +#define VISIT_BODY( node ) \ + VISIT_START( node ); \ + if( children_guard ) { \ + Visitor::visit( node ); \ + } \ + VISIT_END( node ); \ + + +#define MUTATE_BODY( type, node ) \ + MUTATE_START( node ); \ + if( children_guard ) { \ + Mutator::mutate( node ); \ + } \ + MUTATE_END( type, node ); \ @@ -63,5 +63,4 @@ template< typename pass_type > static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) { - DeclList_t* beforeDecls = visitor.get_beforeDecls(); DeclList_t* afterDecls = visitor.get_afterDecls(); @@ -76,5 +75,5 @@ try { // run visitor on declaration - maybeAccept( *i, visitor ); + maybeAccept_impl( *i, visitor ); } catch( SemanticError &e ) { e.set_location( (*i)->location ); @@ -92,5 +91,4 @@ template< typename pass_type > static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) { - DeclList_t* beforeDecls = mutator.get_beforeDecls(); DeclList_t* afterDecls = mutator.get_afterDecls(); @@ -104,5 +102,5 @@ try { // run mutator on declaration - *i = maybeMutate( *i, mutator ); + maybeMutate_impl( *i, mutator ); } catch( SemanticError &e ) { e.set_location( (*i)->location ); @@ -118,6 +116,15 @@ } -template< typename Container, typename VisitorType > -inline void maybeAccept( Container &container, VisitorType &visitor ) { +template< typename TreeType, typename pass_type > +inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) { + if ( ! visitor.get_visit_children() ) return; + if ( tree ) { + tree->accept( visitor ); + } +} + +template< typename Container, typename pass_type > +inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) { + if ( ! visitor.get_visit_children() ) return; SemanticError errors; for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) { @@ -136,11 +143,20 @@ } -template< typename Container, typename MutatorType > -inline void maybeMutateRef( Container &container, MutatorType &mutator ) { +template< typename TreeType, typename pass_type > +inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) { + if ( ! mutator.get_visit_children() ) return; + + if ( tree ) { + tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) ); + } +} + +template< typename Container, typename pass_type > +inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) { + if ( ! mutator.get_visit_children() ) return; SemanticError errors; for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) { try { if ( *i ) { -/// *i = (*i)->acceptMutator( mutator ); *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) ); assert( *i ); @@ -159,4 +175,5 @@ template< typename func_t > void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) { + if ( ! get_visit_children() ) return; SemanticError errors; @@ -199,5 +216,5 @@ void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) { handleStatementList( statements, [this]( Statement * stmt) { - stmt->accept( *this ); + maybeAccept_impl( stmt, *this ); }); } @@ -206,5 +223,5 @@ void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) { handleStatementList( statements, [this]( Statement *& stmt) { - stmt = stmt->acceptMutator( *this ); + maybeMutate_impl( stmt, *this ); }); } @@ -214,4 +231,6 @@ template< typename func_t > Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) { + if ( ! get_visit_children() ) return stmt; + // don't want statements from outer CompoundStmts to be added to this CompoundStmt ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr () ); @@ -244,5 +263,5 @@ Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) { return handleStatement( stmt, [this]( Statement * stmt ) { - maybeAccept( stmt, *this ); + maybeAccept_impl( stmt, *this ); return stmt; }); @@ -252,5 +271,6 @@ Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) { return handleStatement( stmt, [this]( Statement * stmt ) { - return maybeMutate( stmt, *this ); + maybeMutate_impl( stmt, *this ); + return stmt; }); } @@ -259,4 +279,5 @@ template< typename func_t > Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) { + if ( ! get_visit_children() ) return expr; if( !expr ) return nullptr; @@ -266,5 +287,5 @@ } - // should env be cloned (or moved) onto the result of the mutate? + // should env be moved onto the result of the mutate? return func( expr ); } @@ -273,5 +294,5 @@ Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) { return handleExpression(expr, [this]( Expression * expr ) { - expr->accept( *this ); + maybeAccept_impl( expr, *this ); return expr; }); @@ -281,6 +302,27 @@ Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) { return handleExpression(expr, [this]( Expression * expr ) { - return expr->acceptMutator( *this ); + maybeMutate_impl( expr, *this ); + return expr; }); +} + +template< typename TreeType, typename VisitorType > +inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) { + if ( ! visitor.get_visit_children() ) return; + auto guard = makeFuncGuard( + [&visitor]() { visitor.indexerScopeEnter(); }, + [&visitor]() { visitor.indexerScopeLeave(); } + ); + maybeAccept_impl( tree, visitor ); +} + +template< typename TreeType, typename MutatorType > +inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) { + if ( ! mutator.get_visit_children() ) return; + auto guard = makeFuncGuard( + [&mutator]() { mutator.indexerScopeEnter(); }, + [&mutator]() { mutator.indexerScopeLeave(); } + ); + maybeMutate_impl( tree, mutator ); } @@ -319,6 +361,7 @@ indexerScopedAccept( node->type , *this ); - maybeAccept ( node->init , *this ); - maybeAccept ( node->bitfieldWidth, *this ); + maybeAccept_impl ( node->init , *this ); + maybeAccept_impl ( node->bitfieldWidth, *this ); + maybeAccept_impl ( node->attributes , *this ); if ( node->name != "" ) { @@ -334,6 +377,7 @@ indexerScopedMutate( node->type , *this ); - maybeMutateRef ( node->init , *this ); - maybeMutateRef ( node->bitfieldWidth, *this ); + maybeMutate_impl ( node->init , *this ); + maybeMutate_impl ( node->bitfieldWidth, *this ); + maybeMutate_impl ( node->attributes , *this ); if ( node->name != "" ) { @@ -356,6 +400,7 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->type, *this ); - maybeAccept( node->statements, *this ); + maybeAccept_impl( node->type, *this ); + maybeAccept_impl( node->statements, *this ); + maybeAccept_impl( node->attributes, *this ); } @@ -373,6 +418,7 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->type, *this ); - maybeMutateRef( node->statements, *this ); + maybeMutate_impl( node->type, *this ); + maybeMutate_impl( node->statements, *this ); + maybeMutate_impl( node->attributes, *this ); } @@ -392,6 +438,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->parameters, *this ); - maybeAccept( node->members , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->members , *this ); } @@ -412,6 +458,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->parameters, *this ); - maybeMutateRef( node->members , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->members , *this ); } @@ -433,6 +479,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->parameters, *this ); - maybeAccept( node->members , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->members , *this ); } @@ -451,6 +497,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->parameters, *this ); - maybeMutateRef( node->members , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->members , *this ); } @@ -469,6 +515,6 @@ // unlike structs, traits, and unions, enums inject their members into the global scope - maybeAccept( node->parameters, *this ); - maybeAccept( node->members , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->members , *this ); VISIT_END( node ); @@ -482,6 +528,6 @@ // unlike structs, traits, and unions, enums inject their members into the global scope - maybeMutateRef( node->parameters, *this ); - maybeMutateRef( node->members , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->members , *this ); MUTATE_END( Declaration, node ); @@ -496,6 +542,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->parameters, *this ); - maybeAccept( node->members , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->members , *this ); } @@ -511,6 +557,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->parameters, *this ); - maybeMutateRef( node->members , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->members , *this ); } @@ -528,6 +574,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->parameters, *this ); - maybeAccept( node->base , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->base , *this ); } @@ -537,5 +583,5 @@ indexerAddType( node ); - maybeAccept( node->assertions, *this ); + maybeAccept_impl( node->assertions, *this ); indexerScopedAccept( node->init, *this ); @@ -550,6 +596,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->parameters, *this ); - maybeMutateRef( node->base , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->base , *this ); } @@ -559,5 +605,5 @@ indexerAddType( node ); - maybeMutateRef( node->assertions, *this ); + maybeMutate_impl( node->assertions, *this ); indexerScopedMutate( node->init, *this ); @@ -574,11 +620,11 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->parameters, *this ); - maybeAccept( node->base , *this ); + maybeAccept_impl( node->parameters, *this ); + maybeAccept_impl( node->base , *this ); } indexerAddType( node ); - maybeAccept( node->assertions, *this ); + maybeAccept_impl( node->assertions, *this ); VISIT_END( node ); @@ -591,11 +637,11 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef ( node->parameters, *this ); - maybeMutateRef( node->base , *this ); + maybeMutate_impl( node->parameters, *this ); + maybeMutate_impl( node->base , *this ); } indexerAddType( node ); - maybeMutateRef( node->assertions, *this ); + maybeMutate_impl( node->assertions, *this ); MUTATE_END( Declaration, node ); @@ -608,5 +654,5 @@ VISIT_START( node ); - maybeAccept( node->stmt, *this ); + maybeAccept_impl( node->stmt, *this ); VISIT_END( node ); @@ -617,5 +663,5 @@ MUTATE_START( node ); - maybeMutateRef( node->stmt, *this ); + maybeMutate_impl( node->stmt, *this ); MUTATE_END( AsmDecl, node ); @@ -686,6 +732,6 @@ // if statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - acceptAll( node->get_initialization(), *this ); - visitExpression( node->condition ); + maybeAccept_impl( node->get_initialization(), *this ); + visitExpression ( node->condition ); node->thenPart = visitStatement( node->thenPart ); node->elsePart = visitStatement( node->elsePart ); @@ -700,5 +746,5 @@ // if statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->get_initialization(), *this ); + maybeMutate_impl( node->get_initialization(), *this ); node->condition = mutateExpression( node->condition ); node->thenPart = mutateStatement ( node->thenPart ); @@ -738,5 +784,5 @@ // for statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->initialization, *this ); + maybeAccept_impl( node->initialization, *this ); visitExpression( node->condition ); visitExpression( node->increment ); @@ -752,5 +798,5 @@ // for statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->initialization, *this ); + maybeMutate_impl( node->initialization, *this ); node->condition = mutateExpression( node->condition ); node->increment = mutateExpression( node->increment ); @@ -855,7 +901,7 @@ VISIT_START( node ); - maybeAccept( node->block , *this ); - maybeAccept( node->handlers , *this ); - maybeAccept( node->finallyBlock, *this ); + maybeAccept_impl( node->block , *this ); + maybeAccept_impl( node->handlers , *this ); + maybeAccept_impl( node->finallyBlock, *this ); VISIT_END( node ); @@ -866,7 +912,7 @@ MUTATE_START( node ); - maybeMutateRef( node->block , *this ); - maybeMutateRef( node->handlers , *this ); - maybeMutateRef( node->finallyBlock, *this ); + maybeMutate_impl( node->block , *this ); + maybeMutate_impl( node->handlers , *this ); + maybeMutate_impl( node->finallyBlock, *this ); MUTATE_END( Statement, node ); @@ -881,5 +927,5 @@ // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->decl, *this ); + maybeAccept_impl( node->decl, *this ); node->cond = visitExpression( node->cond ); node->body = visitStatement ( node->body ); @@ -894,5 +940,5 @@ // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->decl, *this ); + maybeMutate_impl( node->decl, *this ); node->cond = mutateExpression( node->cond ); node->body = mutateStatement ( node->body ); @@ -968,6 +1014,6 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->function, *this ); - maybeAccept ( node->args , *this ); + maybeAccept_impl ( node->function, *this ); + maybeAccept_impl ( node->args , *this ); VISIT_END( node ); @@ -980,6 +1026,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->function, *this ); - maybeMutateRef ( node->args , *this ); + maybeMutate_impl ( node->function, *this ); + maybeMutate_impl ( node->args , *this ); MUTATE_END( Expression, node ); @@ -992,5 +1038,5 @@ VISIT_START( node ); - // maybeAccept( node->get_env(), *this ); + // maybeAccept_impl( node->get_env(), *this ); indexerScopedAccept( node->result, *this ); @@ -1044,5 +1090,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->arg , *this ); + maybeAccept_impl ( node->arg , *this ); VISIT_END( node ); @@ -1055,5 +1101,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg , *this ); + maybeMutate_impl ( node->arg , *this ); MUTATE_END( Expression, node ); @@ -1067,5 +1113,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept( node->arg, *this ); + maybeAccept_impl( node->arg, *this ); VISIT_END( node ); @@ -1078,5 +1124,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg , *this ); + maybeMutate_impl ( node->arg , *this ); MUTATE_END( Expression, node ); @@ -1090,5 +1136,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->arg , *this ); + maybeAccept_impl ( node->arg , *this ); VISIT_END( node ); @@ -1101,5 +1147,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg , *this ); + maybeMutate_impl ( node->arg , *this ); MUTATE_END( Expression, node ); @@ -1134,6 +1180,6 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->aggregate, *this ); - maybeAccept ( node->member , *this ); + maybeAccept_impl ( node->aggregate, *this ); + maybeAccept_impl ( node->member , *this ); VISIT_END( node ); @@ -1146,6 +1192,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->aggregate, *this ); - maybeMutateRef ( node->member , *this ); + maybeMutate_impl ( node->aggregate, *this ); + maybeMutate_impl ( node->member , *this ); MUTATE_END( Expression, node ); @@ -1159,5 +1205,5 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->aggregate, *this ); + maybeAccept_impl ( node->aggregate, *this ); VISIT_END( node ); @@ -1170,5 +1216,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->aggregate, *this ); + maybeMutate_impl ( node->aggregate, *this ); MUTATE_END( Expression, node ); @@ -1203,5 +1249,5 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( &node->constant, *this ); + maybeAccept_impl ( &node->constant, *this ); VISIT_END( node ); @@ -1214,5 +1260,7 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - node->constant = *maybeMutate( &node->constant, *this ); + Constant * ptr = &node->constant; + maybeMutate_impl( ptr, *this ); + node->constant = *ptr; MUTATE_END( Expression, node ); @@ -1227,7 +1275,7 @@ indexerScopedAccept( node->result, *this ); if ( node->get_isType() ) { - maybeAccept( node->type, *this ); + maybeAccept_impl( node->type, *this ); } else { - maybeAccept( node->expr, *this ); + maybeAccept_impl( node->expr, *this ); } @@ -1242,7 +1290,7 @@ indexerScopedMutate( node->result, *this ); if ( node->get_isType() ) { - maybeMutateRef( node->type, *this ); + maybeMutate_impl( node->type, *this ); } else { - maybeMutateRef( node->expr, *this ); + maybeMutate_impl( node->expr, *this ); } @@ -1258,7 +1306,7 @@ indexerScopedAccept( node->result, *this ); if ( node->get_isType() ) { - maybeAccept( node->type, *this ); + maybeAccept_impl( node->type, *this ); } else { - maybeAccept( node->expr, *this ); + maybeAccept_impl( node->expr, *this ); } @@ -1273,7 +1321,7 @@ indexerScopedMutate( node->result, *this ); if ( node->get_isType() ) { - maybeMutateRef( node->type, *this ); + maybeMutate_impl( node->type, *this ); } else { - maybeMutateRef( node->expr, *this ); + maybeMutate_impl( node->expr, *this ); } @@ -1288,5 +1336,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->type , *this ); + maybeAccept_impl ( node->type , *this ); VISIT_END( node ); @@ -1299,5 +1347,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->type , *this ); + maybeMutate_impl ( node->type , *this ); MUTATE_END( Expression, node ); @@ -1311,6 +1359,6 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->type , *this ); - maybeAccept ( node->member, *this ); + maybeAccept_impl ( node->type , *this ); + maybeAccept_impl ( node->member, *this ); VISIT_END( node ); @@ -1323,6 +1371,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->type , *this ); - maybeMutateRef ( node->member, *this ); + maybeMutate_impl ( node->type , *this ); + maybeMutate_impl ( node->member, *this ); MUTATE_END( Expression, node ); @@ -1336,5 +1384,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->type , *this ); + maybeAccept_impl ( node->type , *this ); VISIT_END( node ); @@ -1347,5 +1395,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->type , *this ); + maybeMutate_impl ( node->type , *this ); MUTATE_END( Expression, node ); @@ -1360,7 +1408,7 @@ indexerScopedAccept( node->result, *this ); if ( node->get_isType() ) { - maybeAccept( node->type, *this ); + maybeAccept_impl( node->type, *this ); } else { - maybeAccept( node->expr, *this ); + maybeAccept_impl( node->expr, *this ); } @@ -1375,7 +1423,7 @@ indexerScopedMutate( node->result, *this ); if ( node->get_isType() ) { - maybeMutateRef( node->type, *this ); + maybeMutate_impl( node->type, *this ); } else { - maybeMutateRef( node->expr, *this ); + maybeMutate_impl( node->expr, *this ); } @@ -1390,6 +1438,6 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->arg1 , *this ); - maybeAccept ( node->arg2 , *this ); + maybeAccept_impl ( node->arg1 , *this ); + maybeAccept_impl ( node->arg2 , *this ); VISIT_END( node ); @@ -1402,6 +1450,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg1 , *this ); - maybeMutateRef ( node->arg2 , *this ); + maybeMutate_impl ( node->arg1 , *this ); + maybeMutate_impl ( node->arg2 , *this ); MUTATE_END( Expression, node ); @@ -1415,7 +1463,7 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->arg1 , *this ); - maybeAccept ( node->arg2 , *this ); - maybeAccept ( node->arg3 , *this ); + maybeAccept_impl ( node->arg1 , *this ); + maybeAccept_impl ( node->arg2 , *this ); + maybeAccept_impl ( node->arg3 , *this ); VISIT_END( node ); @@ -1428,7 +1476,7 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg1 , *this ); - maybeMutateRef ( node->arg2 , *this ); - maybeMutateRef ( node->arg3 , *this ); + maybeMutate_impl ( node->arg1 , *this ); + maybeMutate_impl ( node->arg2 , *this ); + maybeMutate_impl ( node->arg3 , *this ); MUTATE_END( Expression, node ); @@ -1442,6 +1490,6 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->arg1 , *this ); - maybeAccept ( node->arg2 , *this ); + maybeAccept_impl ( node->arg1 , *this ); + maybeAccept_impl ( node->arg2 , *this ); VISIT_END( node ); @@ -1454,6 +1502,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->arg1 , *this ); - maybeMutateRef ( node->arg2 , *this ); + maybeMutate_impl ( node->arg1 , *this ); + maybeMutate_impl ( node->arg2 , *this ); MUTATE_END( Expression, node ); @@ -1467,5 +1515,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->type, *this ); + maybeAccept_impl ( node->type, *this ); VISIT_END( node ); @@ -1478,5 +1526,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->type , *this ); + maybeMutate_impl ( node->type , *this ); MUTATE_END( Expression, node ); @@ -1490,7 +1538,7 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->inout , *this ); - maybeAccept ( node->constraint, *this ); - maybeAccept ( node->operand , *this ); + maybeAccept_impl ( node->inout , *this ); + maybeAccept_impl ( node->constraint, *this ); + maybeAccept_impl ( node->operand , *this ); VISIT_END( node ); @@ -1503,7 +1551,7 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->inout , *this ); - maybeMutateRef ( node->constraint, *this ); - maybeMutateRef ( node->operand , *this ); + maybeMutate_impl ( node->inout , *this ); + maybeMutate_impl ( node->constraint, *this ); + maybeMutate_impl ( node->operand , *this ); MUTATE_END( Expression, node ); @@ -1517,8 +1565,8 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->callExpr , *this ); - maybeAccept ( node->tempDecls , *this ); - maybeAccept ( node->returnDecls, *this ); - maybeAccept ( node->dtors , *this ); + maybeAccept_impl ( node->callExpr , *this ); + maybeAccept_impl ( node->tempDecls , *this ); + maybeAccept_impl ( node->returnDecls, *this ); + maybeAccept_impl ( node->dtors , *this ); VISIT_END( node ); @@ -1531,8 +1579,8 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->callExpr , *this ); - maybeMutateRef ( node->tempDecls , *this ); - maybeMutateRef ( node->returnDecls, *this ); - maybeMutateRef ( node->dtors , *this ); + maybeMutate_impl ( node->callExpr , *this ); + maybeMutate_impl ( node->tempDecls , *this ); + maybeMutate_impl ( node->returnDecls, *this ); + maybeMutate_impl ( node->dtors , *this ); MUTATE_END( Expression, node ); @@ -1546,5 +1594,5 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->callExpr, *this ); + maybeAccept_impl ( node->callExpr, *this ); VISIT_END( node ); @@ -1557,5 +1605,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->callExpr, *this ); + maybeMutate_impl ( node->callExpr, *this ); MUTATE_END( Expression, node ); @@ -1569,5 +1617,5 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->initializer, *this ); + maybeAccept_impl ( node->initializer, *this ); VISIT_END( node ); @@ -1580,5 +1628,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->initializer, *this ); + maybeMutate_impl ( node->initializer, *this ); MUTATE_END( Expression, node ); @@ -1592,6 +1640,6 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->low , *this ); - maybeAccept ( node->high , *this ); + maybeAccept_impl ( node->low , *this ); + maybeAccept_impl ( node->high , *this ); VISIT_END( node ); @@ -1604,6 +1652,6 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->low , *this ); - maybeMutateRef ( node->high , *this ); + maybeMutate_impl ( node->low , *this ); + maybeMutate_impl ( node->high , *this ); MUTATE_END( Expression, node ); @@ -1617,5 +1665,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->exprs , *this ); + maybeAccept_impl ( node->exprs , *this ); VISIT_END( node ); @@ -1628,5 +1676,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->exprs , *this ); + maybeMutate_impl ( node->exprs , *this ); MUTATE_END( Expression, node ); @@ -1640,5 +1688,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->exprs , *this ); + maybeAccept_impl ( node->exprs , *this ); VISIT_END( node ); @@ -1651,5 +1699,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->exprs , *this ); + maybeMutate_impl ( node->exprs , *this ); MUTATE_END( Expression, node ); @@ -1663,5 +1711,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->tuple , *this ); + maybeAccept_impl ( node->tuple , *this ); VISIT_END( node ); @@ -1674,5 +1722,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->tuple , *this ); + maybeMutate_impl ( node->tuple , *this ); MUTATE_END( Expression, node ); @@ -1686,5 +1734,5 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->stmtExpr, *this ); + maybeAccept_impl ( node->stmtExpr, *this ); VISIT_END( node ); @@ -1697,5 +1745,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->stmtExpr, *this ); + maybeMutate_impl ( node->stmtExpr, *this ); MUTATE_END( Expression, node ); @@ -1714,7 +1762,7 @@ indexerScopedAccept( node->result , *this ); - maybeAccept ( node->statements , *this ); - maybeAccept ( node->returnDecls, *this ); - maybeAccept ( node->dtors , *this ); + maybeAccept_impl ( node->statements , *this ); + maybeAccept_impl ( node->returnDecls, *this ); + maybeAccept_impl ( node->dtors , *this ); VISIT_END( node ); @@ -1731,7 +1779,7 @@ indexerScopedMutate( node->result , *this ); - maybeMutateRef ( node->statements , *this ); - maybeMutateRef ( node->returnDecls, *this ); - maybeMutateRef ( node->dtors , *this ); + maybeMutate_impl ( node->statements , *this ); + maybeMutate_impl ( node->returnDecls, *this ); + maybeMutate_impl ( node->dtors , *this ); MUTATE_END( Expression, node ); @@ -1745,5 +1793,5 @@ indexerScopedAccept( node->result, *this ); - maybeAccept ( node->expr , *this ); + maybeAccept_impl ( node->expr , *this ); VISIT_END( node ); @@ -1756,5 +1804,5 @@ indexerScopedMutate( node->env , *this ); indexerScopedMutate( node->result, *this ); - maybeMutateRef ( node->expr , *this ); + maybeMutate_impl ( node->expr , *this ); MUTATE_END( Expression, node ); @@ -1801,6 +1849,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->forall , *this ); - maybeAccept( node->parameters, *this ); + maybeAccept_impl( node->forall , *this ); + maybeAccept_impl( node->parameters, *this ); } @@ -1816,6 +1864,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->forall , *this ); - maybeMutateRef( node->parameters, *this ); + maybeMutate_impl( node->forall , *this ); + maybeMutate_impl( node->parameters, *this ); } @@ -1833,6 +1881,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept( node->forall , *this ); - maybeAccept( node->parameters, *this ); + maybeAccept_impl( node->forall , *this ); + maybeAccept_impl( node->parameters, *this ); } @@ -1848,6 +1896,6 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutateRef( node->forall , *this ); - maybeMutateRef( node->parameters, *this ); + maybeMutate_impl( node->forall , *this ); + maybeMutate_impl( node->parameters, *this ); } @@ -1873,6 +1921,6 @@ VISIT_START( node ); - maybeAccept( node->forall , *this ); - maybeAccept( node->parameters, *this ); + maybeAccept_impl( node->forall , *this ); + maybeAccept_impl( node->parameters, *this ); VISIT_END( node ); @@ -1883,6 +1931,6 @@ MUTATE_START( node ); - maybeMutateRef( node->forall , *this ); - maybeMutateRef( node->parameters, *this ); + maybeMutate_impl( node->forall , *this ); + maybeMutate_impl( node->parameters, *this ); MUTATE_END( Type, node ); @@ -1930,5 +1978,5 @@ VISIT_START( node ); - maybeAccept( node->get_designators(), *this ); + maybeAccept_impl( node->get_designators(), *this ); VISIT_END( node ); @@ -1939,5 +1987,5 @@ MUTATE_START( node ); - maybeMutateRef( node->get_designators(), *this ); + maybeMutate_impl( node->get_designators(), *this ); MUTATE_END( Designation, node ); @@ -1981,4 +2029,9 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( Constant * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( Attribute * node ) { VISIT_BODY( node ); } @@ -2069,2 +2122,21 @@ MUTATE_BODY( Constant, node ); } + +template< typename pass_type > +Attribute * PassVisitor< pass_type >::mutate( Attribute * node ) { + MUTATE_BODY( Attribute, node ); +} + +template< typename pass_type > +TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) { + MUTATE_START( node ); + + for ( auto & p : node->typeEnv ) { + indexerScopedMutate( p.second, *this ); + } + for ( auto & p : node->varEnv ) { + indexerScopedMutate( p.second, *this ); + } + + MUTATE_END( TypeSubstitution, node ); +} Index: src/Common/PassVisitor.proto.h =================================================================== --- src/Common/PassVisitor.proto.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Common/PassVisitor.proto.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -46,39 +46,42 @@ ~bool_ref() = default; - operator bool() { return *m_ref; } + operator bool() { return m_ref ? *m_ref : true; } bool operator=( bool val ) { return *m_ref = val; } private: - template - friend class PassVisitor; - - void set( bool & val ) { m_ref = &val; }; - - bool * m_ref; + friend class ChildrenGuard; + + bool * set( bool & val ) { + bool * prev = m_ref; + m_ref = &val; + return prev; + } + + bool * m_ref = nullptr; }; -template< typename TreeType, typename VisitorType > -inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) { - auto guard = makeFuncGuard( - [&visitor]() { visitor.indexerScopeEnter(); }, - [&visitor]() { visitor.indexerScopeLeave(); } - ); - maybeAccept( tree, visitor ); -} - -template< typename TreeType, typename MutatorType > -inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) { - auto guard = makeFuncGuard( - [&mutator]() { mutator.indexerScopeEnter(); }, - [&mutator]() { mutator.indexerScopeLeave(); } - ); - tree = maybeMutate( tree, mutator ); -} - -template< typename TreeType, typename MutatorType > -inline void maybeMutateRef( TreeType *& tree, MutatorType & mutator ) { - tree = maybeMutate( tree, mutator ); -} +class ChildrenGuard { +public: + + ChildrenGuard( bool_ref * ref ) + : m_val ( true ) + , m_prev( ref ? ref->set( m_val ) : nullptr ) + , m_ref ( ref ) + {} + + ~ChildrenGuard() { + if( m_ref ) { + m_ref->set( *m_prev ); + } + } + + operator bool() { return m_val; } + +private: + bool m_val; + bool * m_prev; + bool_ref * m_ref; +}; //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Common/utility.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -18,4 +18,5 @@ #include #include +#include #include #include @@ -27,4 +28,6 @@ #include + +#include "Common/Indenter.h" template< typename T > @@ -75,9 +78,9 @@ template< typename Container > -void printAll( const Container &container, std::ostream &os, int indent = 0 ) { +void printAll( const Container &container, std::ostream &os, Indenter indent = {} ) { for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) { if ( *i ) { - os << std::string( indent, ' ' ); - (*i)->print( os, indent + 2 ); + os << indent; + (*i)->print( os, indent ); // need an endl after each element because it's not easy to know when each individual item should end os << std::endl; @@ -351,14 +354,16 @@ template< typename T1, typename T2 > struct group_iterate_t { +private: + std::tuple args; +public: group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) { assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size()); }; + typedef std::tuple(args).begin()), decltype(*std::get<1>(args).begin())> value_type; + typedef decltype(std::get<0>(args).begin()) T1Iter; + typedef decltype(std::get<1>(args).begin()) T2Iter; + struct iterator { - typedef typename std::remove_reference::type T1val; - typedef typename std::remove_reference::type T2val; - typedef std::tuple value_type; - typedef typename T1val::iterator T1Iter; - typedef typename T2val::iterator T2Iter; typedef std::tuple IterTuple; IterTuple it; @@ -370,9 +375,7 @@ value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); } }; + iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); } iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); } - -private: - std::tuple args; }; Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Concurrency/Keywords.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -196,4 +196,5 @@ std::list findMutexArgs( FunctionDecl* ); void validate( DeclarationWithType * ); + void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list &); void addStatments( FunctionDecl* func, CompoundStmt *, const std::list &); @@ -206,4 +207,5 @@ StructDecl* monitor_decl = nullptr; StructDecl* guard_decl = nullptr; + StructDecl* dtor_guard_decl = nullptr; static std::unique_ptr< Type > generic_func; @@ -229,4 +231,5 @@ void postvisit( FunctionDecl * decl ); + void previsit ( StructDecl * decl ); void addStartStatement( FunctionDecl * decl, DeclarationWithType * param ); @@ -236,4 +239,8 @@ acceptAll( translationUnit, impl ); } + + private : + bool thread_ctor_seen = false; + StructDecl * thread_decl = nullptr; }; @@ -403,4 +410,10 @@ if( mutexArgs.empty() ) return; + if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl ); + + bool isDtor = CodeGen::isDestructor( decl->name ); + + if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl ); + for(auto arg : mutexArgs) { validate( arg ); @@ -412,6 +425,12 @@ if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include ", decl ); if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include ", decl ); - - addStatments( decl, body, mutexArgs ); + if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include ", decl ); + + if( isDtor ) { + addDtorStatments( decl, body, mutexArgs ); + } + else { + addStatments( decl, body, mutexArgs ); + } } @@ -425,4 +444,8 @@ assert( !guard_decl ); guard_decl = decl; + } + else if( decl->name == "monitor_dtor_guard_t" ) { + assert( !dtor_guard_decl ); + dtor_guard_decl = decl; } } @@ -457,4 +480,55 @@ //Make sure that typed isn't mutex if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg ); + } + + void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list & args ) { + Type * arg_type = args.front()->get_type()->clone(); + arg_type->set_mutex( false ); + + ObjectDecl * monitors = new ObjectDecl( + "__monitor", + noStorage, + LinkageSpec::Cforall, + nullptr, + new PointerType( + noQualifiers, + new StructInstType( + noQualifiers, + monitor_decl + ) + ), + new SingleInit( new UntypedExpr( + new NameExpr( "get_monitor" ), + { new CastExpr( new VariableExpr( args.front() ), arg_type ) } + )) + ); + + assert(generic_func); + + //in reverse order : + // monitor_guard_t __guard = { __monitors, #, func }; + body->push_front( + new DeclStmt( noLabels, new ObjectDecl( + "__guard", + noStorage, + LinkageSpec::Cforall, + nullptr, + new StructInstType( + noQualifiers, + dtor_guard_decl + ), + new ListInit( + { + new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ), + new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) ) + }, + noDesignators, + true + ) + )) + ); + + //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) }; + body->push_front( new DeclStmt( noLabels, monitors) ); } @@ -523,11 +597,27 @@ // General entry routine //============================================================================================= + void ThreadStarter::previsit( StructDecl * decl ) { + if( decl->name == "thread_desc" && decl->body ) { + assert( !thread_decl ); + thread_decl = decl; + } + } + void ThreadStarter::postvisit(FunctionDecl * decl) { if( ! CodeGen::isConstructor(decl->name) ) return; + Type * typeof_this = InitTweak::getTypeofThis(decl->type); + StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this ); + if( ctored_type && ctored_type->baseStruct == thread_decl ) { + thread_ctor_seen = true; + } + DeclarationWithType * param = decl->get_functionType()->get_parameters().front(); auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) ); - // if( type ) std::cerr << "FRED2" << std::endl; if( type && type->get_baseStruct()->is_thread() ) { + if( !thread_decl || !thread_ctor_seen ) { + throw SemanticError("thread keyword requires threads to be in scope, add #include "); + } + addStartStatement( decl, param ); } Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Concurrency/Waitfor.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -27,5 +27,5 @@ #include "InitTweak/InitTweak.h" // for getPointerBase #include "Parser/LinkageSpec.h" // for Cforall -#include "SymTab/AddVisit.h" // for acceptAndAdd +#include "ResolvExpr/Resolver.h" // for findVoidExpression #include "SynTree/Constant.h" // for Constant #include "SynTree/Declaration.h" // for StructDecl, FunctionDecl, ObjectDecl @@ -112,5 +112,5 @@ //============================================================================================= - class GenerateWaitForPass final : public WithStmtsToAdd { + class GenerateWaitForPass final : public WithIndexer { public: @@ -126,9 +126,11 @@ ObjectDecl * declare( unsigned long count, CompoundStmt * stmt ); + ObjectDecl * declareFlag( CompoundStmt * stmt ); + Statement * makeSetter( ObjectDecl * flag ); ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ); - void init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ); - Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt ); - Expression * call(); - void choose(); + void init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt ); + Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt ); + Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt); + void choose( WaitForStmt * waitfor, Expression * result, CompoundStmt * stmt ); static void implement( std::list< Declaration * > & translationUnit ) { @@ -140,15 +142,15 @@ private: FunctionDecl * decl_waitfor = nullptr; + StructDecl * decl_mask = nullptr; StructDecl * decl_acceptable = nullptr; StructDecl * decl_monitor = nullptr; - DeclarationWithType * decl_m_func = nullptr; - DeclarationWithType * decl_m_count = nullptr; - DeclarationWithType * decl_m_monitors = nullptr; - DeclarationWithType * decl_m_isdtor = nullptr; static std::unique_ptr< Type > generic_func; + UniqueName namer_acc = "__acceptables_"s; + UniqueName namer_idx = "__index_"s; + UniqueName namer_flg = "__do_run_"s; + UniqueName namer_msk = "__mask_"s; UniqueName namer_mon = "__monitors_"s; - UniqueName namer_acc = "__acceptables_"s; UniqueName namer_tim = "__timeout_"s; }; @@ -167,5 +169,5 @@ namespace { Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) { - return new ApplicationExpr( + return new UntypedExpr( new NameExpr( "?[?]" ), { @@ -177,5 +179,5 @@ Expression * makeOpAssign( Expression * lhs, Expression * rhs ) { - return new ApplicationExpr( + return new UntypedExpr( new NameExpr( "?=?" ), { lhs, rhs } @@ -183,22 +185,23 @@ } - Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) { - return new MemberExpr( mem, sue ); - } - - Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) { - return new ExprStmt( - noLabels, - makeOpAssign( - makeOpMember( - makeOpIndex( - object, - index - ), - member + Expression * makeOpMember( Expression * sue, const std::string & mem ) { + return new UntypedMemberExpr( new NameExpr( mem ), sue ); + } + + Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) { + Expression * expr = makeOpAssign( + makeOpMember( + makeOpIndex( + object, + index ), - value - ) + member + ), + value ); + + ResolvExpr::findVoidExpression( expr, indexer ); + + return new ExprStmt( noLabels, expr ); } @@ -208,4 +211,19 @@ return new ConstantExpr( Constant::from_bool( ifnull ) ); } + + VariableExpr * extractVariable( Expression * func ) { + if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) { + return var; + } + + CastExpr * cast = strict_dynamic_cast< CastExpr * >( func ); + return strict_dynamic_cast< VariableExpr * >( cast->arg ); + } + + Expression * detectIsDtor( Expression * func ) { + VariableExpr * typed_func = extractVariable( func ); + bool is_dtor = InitTweak::isDestructor( typed_func->var ); + return new ConstantExpr( Constant::from_bool( is_dtor ) ); + } }; @@ -216,5 +234,5 @@ void GenerateWaitForPass::premutate( FunctionDecl * decl) { - if( decl->name != "__accept_internal" ) return; + if( decl->name != "__waitfor_internal" ) return; decl_waitfor = decl; @@ -227,11 +245,8 @@ assert( !decl_acceptable ); decl_acceptable = decl; - for( Declaration * field : decl_acceptable->members ) { - if( field->name == "func" ) decl_m_func = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "count" ) decl_m_count = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "is_dtor" ) decl_m_isdtor = strict_dynamic_cast< DeclarationWithType * >( field ); - } - + } + else if( decl->name == "__waitfor_mask_t" ) { + assert( !decl_mask ); + decl_mask = decl; } else if( decl->name == "monitor_desc" ) { @@ -242,15 +257,15 @@ Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) { - return waitfor; - - if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include ", waitfor ); + if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include ", waitfor ); CompoundStmt * stmt = new CompoundStmt( noLabels ); ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt ); + ObjectDecl * flag = declareFlag( stmt ); + Statement * setter = makeSetter( flag ); int index = 0; for( auto & clause : waitfor->clauses ) { - init( acceptables, index, clause, stmt ); + init( acceptables, index, clause, setter, stmt ); index++; @@ -262,10 +277,19 @@ waitfor->orelse .statement, waitfor->orelse .condition, + setter, stmt ); - // Expression * result = call( acceptables, timeout, orelse, stmt ); - - // choose( waitfor, result ); + CompoundStmt * compound = new CompoundStmt( noLabels ); + stmt->push_back( new IfStmt( + noLabels, + safeCond( new VariableExpr( flag ) ), + compound, + nullptr + )); + + Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound ); + + choose( waitfor, result, compound ); return stmt; @@ -274,9 +298,6 @@ ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt ) { - ObjectDecl * acceptables = new ObjectDecl( + ObjectDecl * acceptables = ObjectDecl::newObject( namer_acc.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new ArrayType( noQualifiers, @@ -294,19 +315,61 @@ stmt->push_back( new DeclStmt( noLabels, acceptables) ); + Expression * set = new UntypedExpr( + new NameExpr( "__builtin_memset" ), + { + new VariableExpr( acceptables ), + new ConstantExpr( Constant::from_int( 0 ) ), + new SizeofExpr( new VariableExpr( acceptables ) ) + } + ); + + ResolvExpr::findVoidExpression( set, indexer ); + + stmt->push_back( new ExprStmt( noLabels, set ) ); + return acceptables; } + ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) { + ObjectDecl * flag = ObjectDecl::newObject( + namer_flg.newName(), + new BasicType( + noQualifiers, + BasicType::Bool + ), + new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) ) + ); + + stmt->push_back( new DeclStmt( noLabels, flag) ); + + return flag; + } + + Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) { + Expression * expr = new UntypedExpr( + new NameExpr( "?=?" ), + { + new VariableExpr( flag ), + new ConstantExpr( Constant::from_ulong( 1 ) ) + } + ); + + ResolvExpr::findVoidExpression( expr, indexer ); + + return new ExprStmt( noLabels, expr ); + } + ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) { - ObjectDecl * mon = new ObjectDecl( + ObjectDecl * mon = ObjectDecl::newObject( namer_mon.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new ArrayType( noQualifiers, - new StructInstType( + new PointerType( noQualifiers, - decl_monitor + new StructInstType( + noQualifiers, + decl_monitor + ) ), new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), @@ -316,5 +379,20 @@ new ListInit( map_range < std::list > ( clause.target.arguments, [this](Expression * expr ){ - return new SingleInit( expr ); + Expression * init = new CastExpr( + new UntypedExpr( + new NameExpr( "get_monitor" ), + { expr } + ), + new PointerType( + noQualifiers, + new StructInstType( + noQualifiers, + decl_monitor + ) + ) + ); + + ResolvExpr::findSingleExpression( init, indexer ); + return new SingleInit( init ); }) ) @@ -326,18 +404,20 @@ } - void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) { + void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) { ObjectDecl * monitors = declMon( clause, stmt ); - CompoundStmt * compound = new CompoundStmt( noLabels ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_func , clause.target.function ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_count , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor , new ConstantExpr( Constant::from_bool( true ) ) ) ); + Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) ); stmt->push_back( new IfStmt( noLabels, safeCond( clause.condition ), - compound, + new CompoundStmt({ + makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function ) , indexer ), + makeAccStatement( acceptables, index, "func" , new CastExpr( clause.target.function, fptr_t ) , indexer ), + makeAccStatement( acceptables, index, "list" , new VariableExpr( monitors ) , indexer ), + makeAccStatement( acceptables, index, "size" , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ), + setter->clone() + }), nullptr )); @@ -353,11 +433,9 @@ bool has_else, Expression *& else_cond, + Statement * setter, CompoundStmt * stmt ) { - ObjectDecl * timeout = new ObjectDecl( + ObjectDecl * timeout = ObjectDecl::newObject( namer_tim.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new BasicType( noQualifiers, @@ -374,12 +452,15 @@ stmt->push_back( new IfStmt( noLabels, - safeCond( else_cond ), - new ExprStmt( - noLabels, - makeOpAssign( - new VariableExpr( timeout ), - time - ) - ), + safeCond( time_cond ), + new CompoundStmt({ + new ExprStmt( + noLabels, + makeOpAssign( + new VariableExpr( timeout ), + time + ) + ), + setter->clone() + }), nullptr )); @@ -392,11 +473,14 @@ noLabels, safeCond( else_cond ), - new ExprStmt( - noLabels, - makeOpAssign( - new VariableExpr( timeout ), - new ConstantExpr( Constant::from_ulong( 0 ) ) - ) - ), + new CompoundStmt({ + new ExprStmt( + noLabels, + makeOpAssign( + new VariableExpr( timeout ), + new ConstantExpr( Constant::from_ulong( 0 ) ) + ) + ), + setter->clone() + }), nullptr )); @@ -405,5 +489,130 @@ } + delete setter; + return new VariableExpr( timeout ); + } + + Expression * GenerateWaitForPass::call( + size_t count, + ObjectDecl * acceptables, + Expression * timeout, + CompoundStmt * stmt + ) { + ObjectDecl * index = ObjectDecl::newObject( + namer_idx.newName(), + new BasicType( + noQualifiers, + BasicType::ShortSignedInt + ), + new SingleInit( + new ConstantExpr( Constant::from_int( -1 ) ) + ) + ); + + stmt->push_back( new DeclStmt( noLabels, index ) ); + + ObjectDecl * mask = ObjectDecl::newObject( + namer_msk.newName(), + new StructInstType( + noQualifiers, + decl_mask + ), + new ListInit({ + new SingleInit( new AddressExpr( new VariableExpr( index ) ) ), + new SingleInit( new VariableExpr( acceptables ) ), + new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) + }) + ); + + stmt->push_back( new DeclStmt( noLabels, mask ) ); + + stmt->push_back( new ExprStmt( + noLabels, + new ApplicationExpr( + VariableExpr::functionPointer( decl_waitfor ), + { + new CastExpr( + new VariableExpr( mask ), + new ReferenceType( + noQualifiers, + new StructInstType( + noQualifiers, + decl_mask + ) + ) + ), + timeout + } + ) + )); + + return new VariableExpr( index ); + } + + void GenerateWaitForPass::choose( + WaitForStmt * waitfor, + Expression * result, + CompoundStmt * stmt + ) { + SwitchStmt * swtch = new SwitchStmt( + noLabels, + result, + std::list() + ); + + unsigned long i = 0; + for( auto & clause : waitfor->clauses ) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_ulong( i++ ) ), + { + clause.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + if(waitfor->timeout.statement) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_int( -2 ) ), + { + waitfor->timeout.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + if(waitfor->orelse.statement) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_int( -1 ) ), + { + waitfor->orelse.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + stmt->push_back( swtch ); } }; Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/Box.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -32,5 +32,4 @@ #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for toString -#include "DeclMutator.h" // for DeclMutator #include "FindFunction.h" // for findFunction, findAndReplace... #include "GenPoly/ErasableScopedMap.h" // for ErasableScopedMap<>::const_i... @@ -39,5 +38,4 @@ #include "Lvalue.h" // for generalizedLvalue #include "Parser/LinkageSpec.h" // for C, Spec, Cforall, Intrinsic -#include "PolyMutator.h" // for PolyMutator #include "ResolvExpr/TypeEnvironment.h" // for EqvClass #include "ResolvExpr/typeops.h" // for typesCompatible @@ -62,35 +60,37 @@ FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ); + class BoxPass { + protected: + BoxPass() : scopeTyVars( TypeDecl::Data{} ) {} + TyVarMap scopeTyVars; + }; + /// Adds layout-generation functions to polymorphic types - class LayoutFunctionBuilder final : public DeclMutator { - unsigned int functionNesting; // current level of nested functions + class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef, public WithShortCircuiting { + unsigned int functionNesting = 0; // current level of nested functions public: - LayoutFunctionBuilder() : functionNesting( 0 ) {} - - using DeclMutator::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual Declaration *mutate( StructDecl *structDecl ) override; - virtual Declaration *mutate( UnionDecl *unionDecl ) override; + void previsit( FunctionDecl *functionDecl ); + void previsit( StructDecl *structDecl ); + void previsit( UnionDecl *unionDecl ); }; /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call - class Pass1 final : public PolyMutator { + class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef, public WithShortCircuiting { public: Pass1(); - using PolyMutator::mutate; - virtual Expression *mutate( ApplicationExpr *appExpr ) override; - virtual Expression *mutate( AddressExpr *addrExpr ) override; - virtual Expression *mutate( UntypedExpr *expr ) override; - virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override; - virtual TypeDecl *mutate( TypeDecl *typeDecl ) override; - virtual Expression *mutate( CommaExpr *commaExpr ) override; - virtual Expression *mutate( ConditionalExpr *condExpr ) override; - virtual Statement * mutate( ReturnStmt *returnStmt ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type * mutate( FunctionType *functionType ) override; - - virtual void doBeginScope() override; - virtual void doEndScope() override; + void premutate( FunctionDecl * functionDecl ); + void premutate( TypeDecl * typeDecl ); + void premutate( CommaExpr * commaExpr ); + Expression * postmutate( ApplicationExpr * appExpr ); + Expression * postmutate( UntypedExpr *expr ); + void premutate( AddressExpr * addrExpr ); + Expression * postmutate( AddressExpr * addrExpr ); + void premutate( ReturnStmt * returnStmt ); + void premutate( PointerType * pointerType ); + void premutate( FunctionType * functionType ); + + void beginScope(); + void endScope(); private: /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application @@ -129,22 +129,14 @@ /// * Moves polymorphic returns in function types to pointer-type parameters /// * adds type size and assertion parameters to parameter lists - class Pass2 final : public PolyMutator { - public: - template< typename DeclClass > - DeclClass *handleDecl( DeclClass *decl ); - template< typename AggDecl > - AggDecl * handleAggDecl( AggDecl * aggDecl ); - - typedef PolyMutator Parent; - using Parent::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override; - virtual StructDecl *mutate( StructDecl *structDecl ) override; - virtual UnionDecl *mutate( UnionDecl *unionDecl ) override; - virtual TraitDecl *mutate( TraitDecl *unionDecl ) override; - virtual TypeDecl *mutate( TypeDecl *typeDecl ) override; - virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type *mutate( FunctionType *funcType ) override; + struct Pass2 final : public BoxPass, public WithGuards { + void handleAggDecl(); + + DeclarationWithType * postmutate( FunctionDecl *functionDecl ); + void premutate( StructDecl *structDecl ); + void premutate( UnionDecl *unionDecl ); + void premutate( TraitDecl *unionDecl ); + void premutate( TypeDecl *typeDecl ); + void premutate( PointerType *pointerType ); + void premutate( FunctionType *funcType ); private: @@ -158,5 +150,5 @@ /// * Calculates polymorphic offsetof expressions from offset array /// * Inserts dynamic calculation of polymorphic type layouts where needed - class PolyGenericCalculator final : public WithGuards, public WithVisitorRef, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution { + class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution { public: PolyGenericCalculator(); @@ -197,23 +189,19 @@ ScopedSet< std::string > knownOffsets; ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName UniqueName bufNamer; ///< Namer for VLA buffers - TyVarMap scopeTyVars; }; /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations. - class Pass3 final : public PolyMutator { - public: + struct Pass3 final : public BoxPass, public WithGuards { template< typename DeclClass > - DeclClass *handleDecl( DeclClass *decl, Type *type ); - - using PolyMutator::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual Declaration *mutate( StructDecl *structDecl ) override; - virtual Declaration *mutate( UnionDecl *unionDecl ) override; - virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override; - virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override; - virtual TypeDecl *mutate( TypeDecl *objectDecl ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type *mutate( FunctionType *funcType ) override; - private: + void handleDecl( DeclClass * decl, Type * type ); + + void premutate( ObjectDecl * objectDecl ); + void premutate( FunctionDecl * functionDecl ); + void premutate( TypedefDecl * typedefDecl ); + void premutate( StructDecl * structDecl ); + void premutate( UnionDecl * unionDecl ); + void premutate( TypeDecl * typeDecl ); + void premutate( PointerType * pointerType ); + void premutate( FunctionType * funcType ); }; } // anonymous namespace @@ -247,25 +235,25 @@ void box( std::list< Declaration *>& translationUnit ) { - LayoutFunctionBuilder layoutBuilder; - Pass1 pass1; - Pass2 pass2; + PassVisitor layoutBuilder; + PassVisitor pass1; + PassVisitor pass2; PassVisitor polyCalculator; - Pass3 pass3; - - layoutBuilder.mutateDeclarationList( translationUnit ); - mutateTranslationUnit/*All*/( translationUnit, pass1 ); - mutateTranslationUnit/*All*/( translationUnit, pass2 ); + PassVisitor pass3; + + acceptAll( translationUnit, layoutBuilder ); + mutateAll( translationUnit, pass1 ); + mutateAll( translationUnit, pass2 ); mutateAll( translationUnit, polyCalculator ); - mutateTranslationUnit/*All*/( translationUnit, pass3 ); + mutateAll( translationUnit, pass3 ); } ////////////////////////////////// LayoutFunctionBuilder //////////////////////////////////////////// - DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) { - functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); + void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) { + visit_children = false; + maybeAccept( functionDecl->get_functionType(), *visitor ); ++functionNesting; - functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + maybeAccept( functionDecl->get_statements(), *visitor ); --functionNesting; - return functionDecl; } @@ -356,11 +344,12 @@ } - Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) { + void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) { // do not generate layout function for "empty" tag structs - if ( structDecl->get_members().empty() ) return structDecl; + visit_children = false; + if ( structDecl->get_members().empty() ) return; // get parameters that can change layout, exiting early if none std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() ); - if ( otypeParams.empty() ) return structDecl; + if ( otypeParams.empty() ) return; // build layout function signature @@ -413,15 +402,15 @@ addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); - addDeclarationAfter( layoutDecl ); - return structDecl; + declsToAddAfter.push_back( layoutDecl ); } - Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) { + void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) { // do not generate layout function for "empty" tag unions - if ( unionDecl->get_members().empty() ) return unionDecl; + visit_children = false; + if ( unionDecl->get_members().empty() ) return; // get parameters that can change layout, exiting early if none std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() ); - if ( otypeParams.empty() ) return unionDecl; + if ( otypeParams.empty() ) return; // build layout function signature @@ -456,6 +445,5 @@ addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); - addDeclarationAfter( layoutDecl ); - return unionDecl; + declsToAddAfter.push_back( layoutDecl ); } @@ -501,31 +489,29 @@ Pass1::Pass1() : tempNamer( "_temp" ) {} - DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) { + void Pass1::premutate( FunctionDecl *functionDecl ) { if ( functionDecl->get_statements() ) { // empty routine body ? // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl; - doBeginScope(); - scopeTyVars.beginScope(); - - DeclarationWithType *oldRetval = retval; + GuardScope( scopeTyVars ); + GuardValue( retval ); // process polymorphic return value retval = nullptr; - if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) { - retval = functionDecl->get_functionType()->get_returnVals().front(); + FunctionType *functionType = functionDecl->type; + if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) { + retval = functionType->returnVals.front(); // give names to unnamed return values - if ( retval->get_name() == "" ) { - retval->set_name( "_retparm" ); - retval->set_linkage( LinkageSpec::C ); + if ( retval->name == "" ) { + retval->name = "_retparm"; + retval->linkage = LinkageSpec::C; } // if } // if - FunctionType *functionType = functionDecl->get_functionType(); - makeTyVarMap( functionDecl->get_functionType(), scopeTyVars ); - - std::list< DeclarationWithType *> ¶mList = functionType->get_parameters(); + makeTyVarMap( functionType, scopeTyVars ); + + std::list< DeclarationWithType *> ¶mList = functionType->parameters; std::list< FunctionType *> functions; - for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) { + for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) { + for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) { findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter ); } // for @@ -542,21 +528,13 @@ } // if } // for - - functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) ); - - scopeTyVars.endScope(); - retval = oldRetval; - doEndScope(); // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl; } // if - return functionDecl; - } - - TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) { + } + + void Pass1::premutate( TypeDecl *typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - return dynamic_cast( Mutator::mutate( typeDecl ) ); - } - - Expression *Pass1::mutate( CommaExpr *commaExpr ) { + } + + void Pass1::premutate( CommaExpr *commaExpr ) { // Attempting to find application expressions that were mutated by the copy constructor passes // to use an explicit return variable, so that the variable can be reused as a parameter to the @@ -574,16 +552,4 @@ } } - - commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) ); - commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) ); - return commaExpr; - } - - Expression *Pass1::mutate( ConditionalExpr *condExpr ) { - condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) ); - condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) ); - condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) ); - return condExpr; - } @@ -634,5 +600,5 @@ // add size/align for generic types to parameter list - if ( ! appExpr->get_function()->has_result() ) return; + if ( ! appExpr->get_function()->result ) return; FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() ); assert( funcType ); @@ -659,5 +625,5 @@ ObjectDecl *Pass1::makeTemporary( Type *type ) { ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 ); - stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) ); return newObj; } @@ -748,39 +714,53 @@ void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) { - assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() ); - if ( isPolyType( param, exprTyVars ) ) { - Type * newType = arg->get_result()->clone(); + assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() ); + if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return; + + if ( arg->result->get_lvalue() ) { + // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations. + // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) { + // if ( dynamic_cast( varExpr->var->get_type() ) ){ + // // temporary hack - don't box arrays, because &arr is not the same as &arr[0] + // return; + // } + // } + arg = generalizedLvalue( new AddressExpr( arg ) ); + if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) { + // silence warnings by casting boxed parameters when the actual type does not match up with the formal type. + arg = new CastExpr( arg, param->clone() ); + } + } else { + // use type computed in unification to declare boxed variables + Type * newType = param->clone(); if ( env ) env->apply( newType ); - std::unique_ptr manager( newType ); - if ( isPolyType( newType ) ) { - // if the argument's type is polymorphic, we don't need to box again! - return; - } else if ( arg->get_result()->get_lvalue() ) { - // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations. - // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) { - // if ( dynamic_cast( varExpr->var->get_type() ) ){ - // // temporary hack - don't box arrays, because &arr is not the same as &arr[0] - // return; - // } - // } - arg = generalizedLvalue( new AddressExpr( arg ) ); - if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) { - // silence warnings by casting boxed parameters when the actual type does not match up with the formal type. - arg = new CastExpr( arg, param->clone() ); - } - } else { - // use type computed in unification to declare boxed variables - Type * newType = param->clone(); - if ( env ) env->apply( newType ); - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 ); - newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? - stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); - UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax? - assign->get_args().push_back( new VariableExpr( newObj ) ); - assign->get_args().push_back( arg ); - stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) ); - arg = new AddressExpr( new VariableExpr( newObj ) ); - } // if + ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr ); + newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) ); + UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax? + assign->get_args().push_back( new VariableExpr( newObj ) ); + assign->get_args().push_back( arg ); + stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) ); + arg = new AddressExpr( new VariableExpr( newObj ) ); } // if + } + + // find instances of polymorphic type parameters + struct PolyFinder { + const TyVarMap * tyVars = nullptr; + bool found = false; + + void previsit( TypeInstType * t ) { + if ( isPolyType( t, *tyVars ) ) { + found = true; + } + } + }; + + // true if there is an instance of a polymorphic type parameter in t + bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) { + PassVisitor finder; + finder.pass.tyVars = &tyVars; + maybeAccept( t, finder ); + return finder.pass.found; } @@ -789,5 +769,7 @@ /// this gets rid of warnings from gcc. void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) { - if ( getFunctionType( formal ) ) { + // type contains polymorphism, but isn't exactly a polytype, in which case it + // has some real actual type (e.g. unsigned int) and casting to void * is wrong + if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) { Type * newType = formal->clone(); newType = ScrubTyVars::scrub( newType, tyVars ); @@ -797,6 +779,6 @@ void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) { - for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) { - assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() ); + for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) { + assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() ); addCast( *arg, (*param)->get_type(), exprTyVars ); boxParam( (*param)->get_type(), *arg, exprTyVars ); @@ -807,10 +789,7 @@ std::list< Expression *>::iterator cur = arg; for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) { + for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) { InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() ); - if ( inferParam == appExpr->get_inferParams().end() ) { - std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl; - } - assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" ); + assertf( inferParam != appExpr->get_inferParams().end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() ); Expression *newExpr = inferParam->second.expr->clone(); addCast( newExpr, (*assert)->get_type(), tyVars ); @@ -822,5 +801,5 @@ void makeRetParm( FunctionType *funcType ) { - DeclarationWithType *retParm = funcType->get_returnVals().front(); + DeclarationWithType *retParm = funcType->returnVals.front(); // make a new parameter that is a pointer to the type of the old return value @@ -835,5 +814,4 @@ // actually make the adapter type FunctionType *adapter = adaptee->clone(); -// if ( ! adapter->get_returnVals().empty() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) { if ( isDynRet( adapter, tyVars ) ) { makeRetParm( adapter ); @@ -961,5 +939,5 @@ std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) ); adapter = answer.first; - stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) ); } // if assert( adapter != adapters.end() ); @@ -999,5 +977,5 @@ if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) { if ( varExpr->get_var()->get_name() == "?[?]" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( appExpr->get_args().size() == 2 ); Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env ); @@ -1033,5 +1011,5 @@ } // if } else if ( varExpr->get_var()->get_name() == "*?" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( ! appExpr->get_args().empty() ); if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) { @@ -1050,5 +1028,5 @@ } // if } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( appExpr->get_args().size() == 1 ); if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) { @@ -1070,5 +1048,5 @@ } // if } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( appExpr->get_args().size() == 1 ); if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) { @@ -1076,5 +1054,5 @@ } // if } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( appExpr->get_args().size() == 2 ); Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env ); @@ -1102,5 +1080,5 @@ } // if } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) { - assert( appExpr->has_result() ); + assert( appExpr->result ); assert( appExpr->get_args().size() == 2 ); Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ); @@ -1118,5 +1096,5 @@ } - Expression *Pass1::mutate( ApplicationExpr *appExpr ) { + Expression *Pass1::postmutate( ApplicationExpr *appExpr ) { // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl; // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) { @@ -1124,10 +1102,8 @@ // } // std::cerr << "\n"; - appExpr->get_function()->acceptMutator( *this ); - mutateAll( appExpr->get_args(), *this ); - - assert( appExpr->get_function()->has_result() ); - FunctionType * function = getFunctionType( appExpr->get_function()->get_result() ); - assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() ); + + assert( appExpr->function->result ); + FunctionType * function = getFunctionType( appExpr->function->result ); + assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() ); if ( Expression *newExpr = handleIntrinsics( appExpr ) ) { @@ -1182,28 +1158,29 @@ } - Expression *Pass1::mutate( UntypedExpr *expr ) { - if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) { - if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) { + Expression * Pass1::postmutate( UntypedExpr *expr ) { + if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) { + if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) { if ( name->get_name() == "*?" ) { - Expression *ret = expr->get_args().front(); - expr->get_args().clear(); + Expression *ret = expr->args.front(); + expr->args.clear(); delete expr; - return ret->acceptMutator( *this ); + return ret; } // if } // if } // if - return PolyMutator::mutate( expr ); - } - - Expression *Pass1::mutate( AddressExpr *addrExpr ) { - assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() ); + return expr; + } + + void Pass1::premutate( AddressExpr * ) { visit_children = false; } + Expression * Pass1::postmutate( AddressExpr * addrExpr ) { + assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() ); bool needs = false; if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) { - if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) { + if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) { if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) { if ( name->get_name() == "*?" ) { if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) { - assert( appExpr->get_function()->has_result() ); + assert( appExpr->get_function()->result ); FunctionType *function = getFunctionType( appExpr->get_function()->get_result() ); assert( function ); @@ -1216,5 +1193,5 @@ // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward // out of the if condition. - addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) ); + addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor ); // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env ); @@ -1231,40 +1208,27 @@ } - Statement * Pass1::mutate( ReturnStmt *returnStmt ) { - if ( retval && returnStmt->get_expr() ) { - assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() ); - delete returnStmt->get_expr(); - returnStmt->set_expr( 0 ); - } else { - returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) ); + void Pass1::premutate( ReturnStmt *returnStmt ) { + if ( retval && returnStmt->expr ) { + assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() ); + delete returnStmt->expr; + returnStmt->expr = nullptr; } // if - return returnStmt; - } - - Type * Pass1::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass1::premutate( PointerType *pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Mutator::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type * Pass1::mutate( FunctionType *functionType ) { - scopeTyVars.beginScope(); + } + + void Pass1::premutate( FunctionType *functionType ) { + GuardScope( scopeTyVars ); makeTyVarMap( functionType, scopeTyVars ); - - Type *ret = Mutator::mutate( functionType ); - - scopeTyVars.endScope(); - return ret; - } - - void Pass1::doBeginScope() { + } + + void Pass1::beginScope() { adapters.beginScope(); } - void Pass1::doEndScope() { + void Pass1::endScope() { adapters.endScope(); } @@ -1293,13 +1257,5 @@ } - template< typename DeclClass > - DeclClass * Pass2::handleDecl( DeclClass *decl ) { - DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) ); - - return ret; - } - - DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) { - functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) ); + DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) { FunctionType * ftype = functionDecl->get_functionType(); if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) { @@ -1325,55 +1281,30 @@ } - ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl ); - } - - template< typename AggDecl > - AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) { + void Pass2::premutate( StructDecl * ) { // prevent tyVars from leaking into containing scope - scopeTyVars.beginScope(); - Parent::mutate( aggDecl ); - scopeTyVars.endScope(); - return aggDecl; - } - - StructDecl * Pass2::mutate( StructDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) { + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( UnionDecl * ) { + // prevent tyVars from leaking into containing scope + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( TraitDecl * ) { + // prevent tyVars from leaking into containing scope + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( TypeDecl *typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - if ( typeDecl->get_base() ) { - return handleDecl( typeDecl ); - } else { - return dynamic_cast( Parent::mutate( typeDecl ) ); - } - } - - TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) { - return handleDecl( typedefDecl ); - } - - Type * Pass2::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass2::premutate( PointerType *pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Parent::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type *Pass2::mutate( FunctionType *funcType ) { - scopeTyVars.beginScope(); - + } + + void Pass2::premutate( FunctionType *funcType ) { + GuardScope( scopeTyVars ); makeTyVarMap( funcType, scopeTyVars ); @@ -1414,5 +1345,4 @@ // move all assertions into parameter list for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) { -// *assert = (*assert)->acceptMutator( *this ); // assertion parameters may not be used in body, pass along with unused attribute. (*assert)->get_attributes().push_back( new Attribute( "unused" ) ); @@ -1450,5 +1380,4 @@ } } - seenTypes.insert( typeName ); } @@ -1458,9 +1387,4 @@ funcType->get_parameters().splice( last, inferredParams ); addAdapters( funcType ); - mutateAll( funcType->get_returnVals(), *this ); - mutateAll( funcType->get_parameters(), *this ); - - scopeTyVars.endScope(); - return funcType; } @@ -1468,5 +1392,5 @@ PolyGenericCalculator::PolyGenericCalculator() - : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {} + : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {} void PolyGenericCalculator::beginTypeScope( Type *ty ) { @@ -1829,74 +1753,47 @@ template< typename DeclClass > - DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) { - scopeTyVars.beginScope(); + void Pass3::handleDecl( DeclClass * decl, Type * type ) { + GuardScope( scopeTyVars ); makeTyVarMap( type, scopeTyVars ); - - DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) ); - // ScrubTyVars::scrub( decl, scopeTyVars ); ScrubTyVars::scrubAll( decl ); - - scopeTyVars.endScope(); - return ret; - } - - ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl, objectDecl->get_type() ); - } - - DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) { - return handleDecl( functionDecl, functionDecl->get_functionType() ); - } - - TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) { - return handleDecl( typedefDecl, typedefDecl->get_base() ); + } + + void Pass3::premutate( ObjectDecl * objectDecl ) { + handleDecl( objectDecl, objectDecl->type ); + } + + void Pass3::premutate( FunctionDecl * functionDecl ) { + handleDecl( functionDecl, functionDecl->type ); + } + + void Pass3::premutate( TypedefDecl * typedefDecl ) { + handleDecl( typedefDecl, typedefDecl->base ); } /// Strips the members from a generic aggregate - void stripGenericMembers(AggregateDecl* decl) { - if ( ! decl->get_parameters().empty() ) decl->get_members().clear(); - } - - Declaration *Pass3::mutate( StructDecl *structDecl ) { + void stripGenericMembers(AggregateDecl * decl) { + if ( ! decl->parameters.empty() ) decl->members.clear(); + } + + void Pass3::premutate( StructDecl * structDecl ) { stripGenericMembers( structDecl ); - return structDecl; - } - - Declaration *Pass3::mutate( UnionDecl *unionDecl ) { + } + + void Pass3::premutate( UnionDecl * unionDecl ) { stripGenericMembers( unionDecl ); - return unionDecl; - } - - TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) { -// Initializer *init = 0; -// std::list< Expression *> designators; -// addToTyVarMap( typeDecl, scopeTyVars ); -// if ( typeDecl->get_base() ) { -// init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators ); -// } -// return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init ); - + } + + void Pass3::premutate( TypeDecl * typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - return dynamic_cast( Mutator::mutate( typeDecl ) ); - } - - Type * Pass3::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass3::premutate( PointerType * pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Mutator::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type * Pass3::mutate( FunctionType *functionType ) { - scopeTyVars.beginScope(); + } + + void Pass3::premutate( FunctionType * functionType ) { + GuardScope( scopeTyVars ); makeTyVarMap( functionType, scopeTyVars ); - - Type *ret = Mutator::mutate( functionType ); - - scopeTyVars.endScope(); - return ret; } } // anonymous namespace Index: src/GenPoly/CopyParams.cc =================================================================== --- src/GenPoly/CopyParams.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,111 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// CopyParams.cc -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Tue May 19 07:33:31 2015 -// Update Count : 1 -// - -#include // for assert -#include // for list, _List_iterator, _List_const_... -#include // for map, _Rb_tree_const_iterator, map<... -#include // for set, set<>::const_iterator -#include // for string, operator== -#include // for pair - -#include "Common/SemanticError.h" // for SemanticError -#include "Common/UniqueName.h" // for UniqueName -#include "SynTree/Declaration.h" // for DeclarationWithType, TypeDecl, Fun... -#include "SynTree/Expression.h" // for VariableExpr, ApplicationExpr, Add... -#include "SynTree/Label.h" // for Label, noLabels -#include "SynTree/Statement.h" // for CompoundStmt, DeclStmt, ExprStmt -#include "SynTree/SynTree.h" // for UniqueId -#include "SynTree/Type.h" // for FunctionType, TypeInstType, Type -#include "SynTree/Visitor.h" // for acceptAll, Visitor - -namespace GenPoly { - class CopyParams : public Visitor { - public: - CopyParams(); - - virtual void visit( FunctionDecl *funcDecl ); - virtual void visit( AddressExpr *addrExpr ); - - private: - std::set< UniqueId > modVars; - UniqueName namer; - }; - - /// creates local copies of polymorphic function parameters - void copyParams( std::list< Declaration* > &translationUnit ) { - CopyParams copier; - acceptAll( translationUnit, copier ); - } - - CopyParams::CopyParams() : namer( "_cp" ) {} - - void CopyParams::visit( FunctionDecl *funcDecl ) { - if ( funcDecl->get_statements() ) { - funcDecl->get_statements()->accept( *this ); - - if ( ! modVars.empty() ) { - std::map< std::string, DeclarationWithType* > assignOps; - // xxx - this needs to use constructors, not assignment operators - // assume the assignment operator is the first assert param after any "type" parameter - for ( Type::ForallList::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) { - if ( (*tyVar)->get_kind() == TypeDecl::Any ) { - assert( !(*tyVar)->get_assertions().empty() ); - assert( (*tyVar)->get_assertions().front()->get_name() == "?=?" ); - assignOps[ (*tyVar)->get_name() ] = (*tyVar)->get_assertions().front(); - } // if - } // for - for ( std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); param != funcDecl->get_functionType()->get_parameters().end(); ++param ) { - std::set< UniqueId >::const_iterator var = modVars.find( (*param)->get_uniqueId() ); - if ( var != modVars.end() ) { - TypeInstType *typeInst = dynamic_cast< TypeInstType* >( (*param)->get_type() ); - assert( typeInst ); - std::map< std::string, DeclarationWithType* >::const_iterator assignOp = assignOps.find( typeInst->get_name() ); - if ( assignOp != assignOps.end() ) { - DeclarationWithType *oldParam = *param; - *param = (*param)->clone(); - (*param)->set_mangleName( namer.newName( (*param)->get_mangleName() ) ); - ApplicationExpr *assign = new ApplicationExpr( new VariableExpr( assignOp->second ) ); - assign->get_args().push_back( new VariableExpr( oldParam ) ); - assign->get_args().push_back( new VariableExpr( *param ) ); - funcDecl->get_statements()->get_kids().push_front( new ExprStmt( noLabels, assign ) ); - funcDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, oldParam ) ); - } // if - modVars.erase( var ); - } // if - } // for - } // if - } // if - } - - // this test is insufficient because it is possible for values to be modified by being passed to other polymorphic - // routines (e.g., assignment operators) without having their addresses explicitly taken. Some thought is needed to - // make sure that all of the correct cases are identified where copies are necessary. - // - // As a temporary measure, for correctness at the expense of performance, ignore the modVars list entirely and copy - // every parameter of TypeInstType* when visiting the FunctionDecl. - void CopyParams::visit( AddressExpr *addrExpr ) { - if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( addrExpr->get_arg() ) ) { - if ( dynamic_cast< TypeInstType* >( varExpr->get_var()->get_type() ) ) { - modVars.insert( varExpr->get_var()->get_uniqueId() ); - } // if - } // if - } -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/CopyParams.h =================================================================== --- src/GenPoly/CopyParams.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,29 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// CopyParams.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:23:09 2017 -// Update Count : 2 -// - -#pragma once - -#include "SynTree/SynTree.h" - -namespace GenPoly { - /// Clones by-value parameters which have been passed by-reference for polymorphism - void copyParams( std::list< Declaration* > &translationUnit ); -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/DeclMutator.cc =================================================================== --- src/GenPoly/DeclMutator.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,195 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// DeclMutator.cc -- -// -// Author : Aaron B. Moss -// Created On : Fri Nov 27 14:44:00 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thu Jun 22 13:49:00 2017 -// Update Count : 4 -// - -#include "DeclMutator.h" - -#include // for allocator_traits<>::value_type - -#include "Common/SemanticError.h" // for SemanticError -#include "SynTree/Declaration.h" // for Declaration -#include "SynTree/Expression.h" // for Expression -#include "SynTree/Label.h" // for Label, noLabels -#include "SynTree/Statement.h" // for CatchStmt, Statement, CompoundStmt - -namespace GenPoly { - DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {} - - DeclMutator::~DeclMutator() {} - - void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) { - for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) { - // splice in new declarations after previous decl - decls.splice( decl, declsToAddAfter.back() ); - - if ( decl == decls.end() ) break; - - // run mutator on declaration - *decl = maybeMutate( *decl, *this ); - - // splice in new declarations before current decl - decls.splice( decl, declsToAdd.back() ); - } - } - - void DeclMutator::doBeginScope() { - // add new decl lists for inside of scope - declsToAdd.resize( declsToAdd.size()+1 ); - declsToAddAfter.resize( declsToAddAfter.size()+1 ); - } - - void DeclMutator::doEndScope() { - // splice any leftover declarations from this scope onto the containing scope - std::vector< std::list< Declaration* > >::reverse_iterator back = declsToAdd.rbegin(); - std::vector< std::list< Declaration* > >::reverse_iterator newBack = back + 1; - newBack->splice( newBack->end(), *back ); - declsToAdd.pop_back(); - - back = declsToAddAfter.rbegin(); - newBack = back + 1; - newBack->splice( newBack->end(), *back ); - declsToAddAfter.pop_back(); - } - - Statement* DeclMutator::mutateStatement( Statement *stmt ) { - // shunt over to compound statement handling if applicable - CompoundStmt *compoundStmt = dynamic_cast< CompoundStmt* >(stmt); - if ( compoundStmt ) return mutate( compoundStmt ); - - doBeginScope(); - - // run mutator on statement - stmt = maybeMutate( stmt, *this ); - // return if no declarations to add - if ( declsToAdd.back().empty() && declsToAddAfter.back().empty() ) { - doEndScope(); - return stmt; - } - - // otherwise add declarations to new compound statement - CompoundStmt *compound = new CompoundStmt( noLabels ); - for ( std::list< Declaration* >::iterator decl = declsToAdd.back().begin(); decl != declsToAdd.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - compound->get_kids().push_back( declStmt ); - } - declsToAdd.back().clear(); - - // add mutated statement - compound->get_kids().push_back( stmt ); - - // add declarations after to new compound statement - for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - compound->get_kids().push_back( declStmt ); - } - declsToAddAfter.back().clear(); - - doEndScope(); - return compound; - } - - void DeclMutator::mutateStatementList( std::list< Statement* > &stmts ) { - doBeginScope(); - - - for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) { - // add any new declarations after the previous statement - for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - stmts.insert( stmt, declStmt ); - } - declsToAddAfter.back().clear(); - - if ( stmt == stmts.end() ) break; - - // run mutator on statement - *stmt = maybeMutate( *stmt, *this ); - - // add any new declarations before the statement - for ( std::list< Declaration* >::iterator decl = declsToAdd.back().begin(); decl != declsToAdd.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - stmts.insert( stmt, declStmt ); - } - declsToAdd.back().clear(); - } - - doEndScope(); - } - - void DeclMutator::addDeclaration( Declaration *decl ) { - declsToAdd.back().push_back( decl ); - } - - void DeclMutator::addDeclarationAfter( Declaration *decl ) { - declsToAddAfter.back().push_back( decl ); - } - - CompoundStmt* DeclMutator::mutate(CompoundStmt *compoundStmt) { - mutateStatementList( compoundStmt->get_kids() ); - return compoundStmt; - } - - Statement* DeclMutator::mutate(IfStmt *ifStmt) { - ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) ); - ifStmt->set_thenPart( mutateStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( mutateStatement( ifStmt->get_elsePart() ) ); - return ifStmt; - } - - Statement* DeclMutator::mutate(WhileStmt *whileStmt) { - whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) ); - whileStmt->set_body( mutateStatement( whileStmt->get_body() ) ); - return whileStmt; - } - - Statement* DeclMutator::mutate(ForStmt *forStmt) { - mutateAll( forStmt->get_initialization(), *this ); - forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) ); - forStmt->set_increment( maybeMutate( forStmt->get_increment(), *this ) ); - forStmt->set_body( mutateStatement( forStmt->get_body() ) ); - return forStmt; - } - - Statement* DeclMutator::mutate(SwitchStmt *switchStmt) { - switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) ); - mutateAll( switchStmt->get_statements(), *this ); - return switchStmt; - } - - Statement* DeclMutator::mutate(CaseStmt *caseStmt) { - caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) ); - mutateAll( caseStmt->get_statements(), *this ); - return caseStmt; - } - - Statement* DeclMutator::mutate(TryStmt *tryStmt) { - tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) ); - mutateAll( tryStmt->get_catchers(), *this ); - tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) ); - return tryStmt; - } - - Statement* DeclMutator::mutate(CatchStmt *catchStmt) { - catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) ); - catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) ); - catchStmt->set_body( mutateStatement( catchStmt->get_body() ) ); - return catchStmt; - } -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/DeclMutator.h =================================================================== --- src/GenPoly/DeclMutator.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,71 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// DeclMutator.h -- -// -// Author : Aaron B. Moss -// Created On : Fri Nov 27 14:44:00 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:21:12 2017 -// Update Count : 4 -// - -#pragma once - -#include // for list -#include // for vector - -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/SynTree.h" // for Visitor Nodes - -namespace GenPoly { - /// Mutates a list of declarations, providing a means of adding new declarations into the list - class DeclMutator : public Mutator { - public: - typedef Mutator Parent; - - DeclMutator(); - virtual ~DeclMutator(); - - using Parent::mutate; - virtual CompoundStmt* mutate(CompoundStmt *compoundStmt); - virtual Statement* mutate(IfStmt *ifStmt); - virtual Statement* mutate(WhileStmt *whileStmt); - virtual Statement* mutate(ForStmt *forStmt); - virtual Statement* mutate(SwitchStmt *switchStmt); - virtual Statement* mutate(CaseStmt *caseStmt); - virtual Statement* mutate(TryStmt *tryStmt); - virtual Statement* mutate(CatchStmt *catchStmt); - - /// Mutates a list of declarations with this visitor - void mutateDeclarationList(std::list< Declaration* >& decls); - - /// Called on entry to a new scope; overriders should call this as a super-class call - virtual void doBeginScope(); - /// Called on exit from a scope; overriders should call this as a super-class call - virtual void doEndScope(); - protected: - /// Mutate a statement that forms its own scope - Statement* mutateStatement( Statement *stmt ); - /// Mutate a list of statements that form a scope - void mutateStatementList( std::list< Statement* > &stmts ); - /// Add a declaration to the list to be added before the current position - void addDeclaration( Declaration* decl ); - /// Add a declaration to the list to be added after the current position - void addDeclarationAfter( Declaration* decl ); - private: - /// A stack of declarations to add before the current declaration or statement - std::vector< std::list< Declaration* > > declsToAdd; - /// A stack of declarations to add after the current declaration or statement - std::vector< std::list< Declaration* > > declsToAddAfter; - }; -} // namespace - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/FindFunction.cc =================================================================== --- src/GenPoly/FindFunction.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/FindFunction.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -18,4 +18,5 @@ #include // for pair +#include "Common/PassVisitor.h" // for PassVisitor #include "Common/SemanticError.h" // for SemanticError #include "GenPoly/ErasableScopedMap.h" // for ErasableScopedMap<>::iterator @@ -27,10 +28,11 @@ namespace GenPoly { - class FindFunction : public Mutator { + class FindFunction : public WithGuards, public WithVisitorRef, public WithShortCircuiting { public: FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate ); - virtual Type *mutate( FunctionType *functionType ); - virtual Type *mutate( PointerType *pointerType ); + void premutate( FunctionType * functionType ); + Type * postmutate( FunctionType * functionType ); + void premutate( PointerType * pointerType ); private: void handleForall( const Type::ForallList &forall ); @@ -43,10 +45,10 @@ void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { - FindFunction finder( functions, tyVars, false, predicate ); + PassVisitor finder( functions, tyVars, false, predicate ); type->acceptMutator( finder ); } void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) { - FindFunction finder( functions, tyVars, true, predicate ); + PassVisitor finder( functions, tyVars, true, predicate ); type = type->acceptMutator( finder ); } @@ -57,6 +59,6 @@ void FindFunction::handleForall( const Type::ForallList &forall ) { - for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) { - TyVarMap::iterator var = tyVars.find( (*i)->get_name() ); + for ( const Declaration * td : forall ) { + TyVarMap::iterator var = tyVars.find( td->name ); if ( var != tyVars.end() ) { tyVars.erase( var->first ); @@ -65,8 +67,12 @@ } - Type * FindFunction::mutate( FunctionType *functionType ) { - tyVars.beginScope(); + void FindFunction::premutate( FunctionType * functionType ) { + visit_children = false; + GuardScope( tyVars ); handleForall( functionType->get_forall() ); - mutateAll( functionType->get_returnVals(), *this ); + mutateAll( functionType->get_returnVals(), *visitor ); + } + + Type * FindFunction::postmutate( FunctionType * functionType ) { Type *ret = functionType; if ( predicate( functionType, tyVars ) ) { @@ -77,14 +83,10 @@ } // if } // if - tyVars.endScope(); return ret; } - Type * FindFunction::mutate( PointerType *pointerType ) { - tyVars.beginScope(); + void FindFunction::premutate( PointerType * pointerType ) { + GuardScope( tyVars ); handleForall( pointerType->get_forall() ); - Type *ret = Mutator::mutate( pointerType ); - tyVars.endScope(); - return ret; } } // namespace GenPoly Index: src/GenPoly/GenPoly.cc =================================================================== --- src/GenPoly/GenPoly.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/GenPoly.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -432,4 +432,22 @@ } + bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) { + // is parameter is not polymorphic, don't need to box + if ( ! isPolyType( param, exprTyVars ) ) return false; + Type * newType = arg->clone(); + if ( env ) env->apply( newType ); + std::unique_ptr manager( newType ); + // if the argument's type is polymorphic, we don't need to box again! + return ! isPolyType( newType ); + } + + bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) { + FunctionType * function = getFunctionType( appExpr->function->result ); + assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() ); + TyVarMap exprTyVars( TypeDecl::Data{} ); + makeTyVarMap( function, exprTyVars ); + return needsBoxing( param, arg, exprTyVars, env ); + } + void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) { // xxx - should this actually be insert? Index: src/GenPoly/GenPoly.h =================================================================== --- src/GenPoly/GenPoly.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/GenPoly.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -80,4 +80,10 @@ bool typesPolyCompatible( Type *aty, Type *bty ); + /// true if arg requires boxing given exprTyVars + bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ); + + /// true if arg requires boxing in the call to appExpr + bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ); + /// Adds the type variable `tyVar` to `tyVarMap` void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ); Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/InstantiateGeneric.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -238,6 +238,6 @@ assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." ); break; - case TypeDecl::Any: - assertf( false, "otype parameters handled by baseParam->isComplete()." ); + default: + assertf( false, "Unhandled type parameter kind" ); break; } @@ -278,5 +278,6 @@ substituteMembers( base->get_members(), baseParams, typeSubs ); - deleteAll( baseParams ); + // xxx - can't delete type parameters because they may have assertions that are used + // deleteAll( baseParams ); baseParams.clear(); Index: src/GenPoly/PolyMutator.cc =================================================================== --- src/GenPoly/PolyMutator.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,187 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// PolyMutator.cc -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thu Jun 22 13:47:00 2017 -// Update Count : 17 -// - -#include "PolyMutator.h" - -#include "Common/SemanticError.h" // for SemanticError -#include "Common/utility.h" // for ValueGuard -#include "SynTree/Declaration.h" // for Declaration, TypeDecl, TypeDecl::Data -#include "SynTree/Expression.h" // for Expression, UntypedExpr, StmtExpr ... -#include "SynTree/Initializer.h" // for SingleInit, Initializer (ptr only) -#include "SynTree/Label.h" // for Label, noLabels -#include "SynTree/Mutator.h" // for maybeMutate, mutateAll -#include "SynTree/Statement.h" // for CatchStmt, CompoundStmt, ForStmt - -class TypeSubstitution; - -namespace GenPoly { - PolyMutator::PolyMutator() : scopeTyVars( TypeDecl::Data{} ), env( 0 ) {} - - void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) { - SemanticError errors; - - for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( i, stmtsToAddAfter ); - } // if - try { - *i = (*i)->acceptMutator( *this ); - } catch ( SemanticError &e ) { - errors.append( e ); - } // try - if ( ! stmtsToAdd.empty() ) { - statements.splice( i, stmtsToAdd ); - } // if - } // for - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( statements.end(), stmtsToAddAfter ); - } // if - if ( ! errors.isEmpty() ) { - throw errors; - } - } - - Statement * PolyMutator::mutateStatement( Statement *stmt ) { - // don't want statements from outer CompoundStmts to be added to this CompoundStmt - ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd ); - ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter ); - ValueGuard< TypeSubstitution * > oldEnv( env ); - stmtsToAdd.clear(); - stmtsToAddAfter.clear(); - - Statement *newStmt = maybeMutate( stmt, *this ); - if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) { - CompoundStmt *compound = new CompoundStmt( noLabels ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAdd ); - compound->get_kids().push_back( newStmt ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAddAfter ); - // doEndScope(); - return compound; - } else { - return newStmt; - } - } - - Expression * PolyMutator::mutateExpression( Expression *expr ) { - if ( expr ) { - if ( expr->get_env() ) { - env = expr->get_env(); - } - // xxx - should env be cloned (or moved) onto the result of the mutate? - return expr->acceptMutator( *this ); - } else { - return expr; - } - } - - CompoundStmt * PolyMutator::mutate(CompoundStmt *compoundStmt) { - doBeginScope(); - mutateStatementList( compoundStmt->get_kids() ); - doEndScope(); - return compoundStmt; - } - - Statement * PolyMutator::mutate(IfStmt *ifStmt) { - ifStmt->set_condition( mutateExpression( ifStmt->get_condition() ) ); - ifStmt->set_thenPart( mutateStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( mutateStatement( ifStmt->get_elsePart() ) ); - return ifStmt; - } - - Statement * PolyMutator::mutate(WhileStmt *whileStmt) { - whileStmt->set_condition( mutateExpression( whileStmt->get_condition() ) ); - whileStmt->set_body( mutateStatement( whileStmt->get_body() ) ); - return whileStmt; - } - - Statement * PolyMutator::mutate(ForStmt *forStmt) { - mutateAll( forStmt->get_initialization(), *this ); - forStmt->set_condition( mutateExpression( forStmt->get_condition() ) ); - forStmt->set_increment( mutateExpression( forStmt->get_increment() ) ); - forStmt->set_body( mutateStatement( forStmt->get_body() ) ); - return forStmt; - } - - Statement * PolyMutator::mutate(SwitchStmt *switchStmt) { - switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) ); - mutateStatementList( switchStmt->get_statements() ); - return switchStmt; - } - - Statement * PolyMutator::mutate(CaseStmt *caseStmt) { - caseStmt->set_condition( mutateExpression( caseStmt->get_condition() ) ); - mutateStatementList( caseStmt->get_statements() ); - return caseStmt; - } - - Statement * PolyMutator::mutate(TryStmt *tryStmt) { - tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) ); - mutateAll( tryStmt->get_catchers(), *this ); - tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) ); - return tryStmt; - } - - Statement * PolyMutator::mutate(CatchStmt *cathStmt) { - cathStmt->set_body( mutateStatement( cathStmt->get_body() ) ); - cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) ); - cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) ); - return cathStmt; - } - - Statement * PolyMutator::mutate(ReturnStmt *retStmt) { - retStmt->set_expr( mutateExpression( retStmt->get_expr() ) ); - return retStmt; - } - - Statement * PolyMutator::mutate(ExprStmt *exprStmt) { - exprStmt->set_expr( mutateExpression( exprStmt->get_expr() ) ); - return exprStmt; - } - - - Expression * PolyMutator::mutate(UntypedExpr *untypedExpr) { - for ( std::list< Expression* >::iterator i = untypedExpr->get_args().begin(); i != untypedExpr->get_args().end(); ++i ) { - *i = mutateExpression( *i ); - } // for - return untypedExpr; - } - - Expression *PolyMutator::mutate( StmtExpr * stmtExpr ) { - // don't want statements from outer CompoundStmts to be added to this StmtExpr - ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd ); - ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter ); - ValueGuard< TypeSubstitution * > oldEnv( env ); - - // xxx - not sure if this is needed, along with appropriate reset, but I don't think so... - // ValueGuard< TyVarMap > oldScopeTyVars( scopeTyVars ); - - stmtsToAdd.clear(); - stmtsToAddAfter.clear(); - // scopeTyVars.clear(); - - return Parent::mutate( stmtExpr ); - } - - Initializer *PolyMutator::mutate( SingleInit *singleInit ) { - singleInit->set_value( mutateExpression( singleInit->get_value() ) ); - return singleInit; - } -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/PolyMutator.h =================================================================== --- src/GenPoly/PolyMutator.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,67 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// PolyMutator.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:20:31 2017 -// Update Count : 7 -// - -#pragma once - -#include // for list - -#include "GenPoly.h" // for TyVarMap -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/SynTree.h" // for Visitor Nodes - -namespace GenPoly { - class PolyMutator : public Mutator { - public: - typedef Mutator Parent; - using Parent::mutate; - - PolyMutator(); - - virtual CompoundStmt* mutate(CompoundStmt *compoundStmt); - virtual Statement* mutate(IfStmt *ifStmt); - virtual Statement* mutate(WhileStmt *whileStmt); - virtual Statement* mutate(ForStmt *forStmt); - virtual Statement* mutate(SwitchStmt *switchStmt); - virtual Statement* mutate(CaseStmt *caseStmt); - virtual Statement* mutate(TryStmt *returnStmt); - virtual Statement* mutate(CatchStmt *catchStmt); - virtual Statement* mutate(ExprStmt *catchStmt); - virtual Statement* mutate(ReturnStmt *catchStmt); - - virtual Expression* mutate(UntypedExpr *untypedExpr); - virtual Expression* mutate( StmtExpr *stmtExpr ); - - virtual Initializer* mutate(SingleInit *SingleInit); - - // template method - virtual void doBeginScope() {} - virtual void doEndScope() {} - protected: - void mutateStatementList( std::list< Statement* > &statements ); - Statement* mutateStatement( Statement *stmt ); - Expression* mutateExpression( Expression *expr ); - - TyVarMap scopeTyVars; - TypeSubstitution *env; - std::list< Statement* > stmtsToAdd; - std::list< Statement* > stmtsToAddAfter; - }; -} // namespace - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/ScrubTyVars.cc =================================================================== --- src/GenPoly/ScrubTyVars.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/ScrubTyVars.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -40,5 +40,4 @@ if ( tyVar != tyVars->end() ) { switch ( tyVar->second.kind ) { - case TypeDecl::Any: case TypeDecl::Dtype: case TypeDecl::Ttype: Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/Specialize.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -22,4 +22,5 @@ #include // for pair +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "Common/UniqueName.h" // for UniqueName @@ -28,5 +29,4 @@ #include "InitTweak/InitTweak.h" // for isIntrinsicCallExpr #include "Parser/LinkageSpec.h" // for C -#include "PolyMutator.h" // for PolyMutator #include "ResolvExpr/FindOpenVars.h" // for findOpenVars #include "ResolvExpr/TypeEnvironment.h" // for OpenVarSet, AssertionSet @@ -43,17 +43,11 @@ namespace GenPoly { - class Specialize final : public PolyMutator { - public: - using PolyMutator::mutate; - virtual Expression * mutate( ApplicationExpr *applicationExpr ) override; - virtual Expression * mutate( AddressExpr *castExpr ) override; - virtual Expression * mutate( CastExpr *castExpr ) override; - // virtual Expression * mutate( LogicalExpr *logicalExpr ); - // virtual Expression * mutate( ConditionalExpr *conditionalExpr ); - // virtual Expression * mutate( CommaExpr *commaExpr ); + struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef { + Expression * postmutate( ApplicationExpr *applicationExpr ); + Expression * postmutate( CastExpr *castExpr ); void handleExplicitParams( ApplicationExpr *appExpr ); Expression * createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ); - Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = nullptr ); + Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ); std::string paramPrefix = "_p"; @@ -72,13 +66,18 @@ if ( ! boundType ) continue; if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) { + // bound to another type variable if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) { + // bound to a closed variable => must specialize return true; } // if } else { + // variable is bound to a concrete type => must specialize return true; } // if } // for + // none of the type variables are bound return false; } else { + // no env return false; } // if @@ -136,7 +135,7 @@ if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false; // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize - if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true; + if ( fftype->parameters.size() != aftype->parameters.size() ) return true; // total parameter size can be the same, while individual parameters can have different structure - for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) { + for ( auto params : group_iterate( fftype->parameters, aftype->parameters ) ) { DeclarationWithType * formal = std::get<0>(params); DeclarationWithType * actual = std::get<1>(params); @@ -152,12 +151,10 @@ Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) { - assertf( actual->has_result(), "attempting to specialize an untyped expression" ); + assertf( actual->result, "attempting to specialize an untyped expression" ); if ( needsSpecialization( formalType, actual->get_result(), env ) ) { if ( FunctionType *funType = getFunctionType( formalType ) ) { - ApplicationExpr *appExpr; - VariableExpr *varExpr; - if ( ( appExpr = dynamic_cast( actual ) ) ) { + if ( ApplicationExpr * appExpr = dynamic_cast( actual ) ) { return createThunkFunction( funType, appExpr->get_function(), inferParams ); - } else if ( ( varExpr = dynamic_cast( actual ) ) ) { + } else if ( VariableExpr * varExpr = dynamic_cast( actual ) ) { return createThunkFunction( funType, varExpr, inferParams ); } else { @@ -204,11 +201,11 @@ } - struct EnvTrimmer : public Visitor { + struct EnvTrimmer { TypeSubstitution * env, * newEnv; EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){} - virtual void visit( TypeDecl * tyDecl ) { + void previsit( TypeDecl * tyDecl ) { // transfer known bindings for seen type variables - if ( Type * t = env->lookup( tyDecl->get_name() ) ) { - newEnv->add( tyDecl->get_name(), t ); + if ( Type * t = env->lookup( tyDecl->name ) ) { + newEnv->add( tyDecl->name, t ); } } @@ -219,5 +216,5 @@ if ( env ) { TypeSubstitution * newEnv = new TypeSubstitution(); - EnvTrimmer trimmer( env, newEnv ); + PassVisitor trimmer( env, newEnv ); expr->accept( trimmer ); return newEnv; @@ -277,25 +274,25 @@ std::string oldParamPrefix = paramPrefix; paramPrefix += "p"; - // save stmtsToAdd in oldStmts + // save stmtsToAddBefore in oldStmts std::list< Statement* > oldStmts; - oldStmts.splice( oldStmts.end(), stmtsToAdd ); - mutate( appExpr ); + oldStmts.splice( oldStmts.end(), stmtsToAddBefore ); + appExpr->acceptMutator( *visitor ); paramPrefix = oldParamPrefix; // write any statements added for recursive specializations into the thunk body - thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd ); - // restore oldStmts into stmtsToAdd - stmtsToAdd.splice( stmtsToAdd.end(), oldStmts ); + thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore ); + // restore oldStmts into stmtsToAddBefore + stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts ); // add return (or valueless expression) to the thunk Statement *appStmt; - if ( funType->get_returnVals().empty() ) { + if ( funType->returnVals.empty() ) { appStmt = new ExprStmt( noLabels, appExpr ); } else { appStmt = new ReturnStmt( noLabels, appExpr ); } // if - thunkFunc->get_statements()->get_kids().push_back( appStmt ); + thunkFunc->statements->kids.push_back( appStmt ); // add thunk definition to queue of statements to add - stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) ); // return address of thunk function as replacement expression return new AddressExpr( new VariableExpr( thunkFunc ) ); @@ -304,18 +301,15 @@ void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) { // create thunks for the explicit parameters - assert( appExpr->get_function()->has_result() ); - FunctionType *function = getFunctionType( appExpr->get_function()->get_result() ); + assert( appExpr->function->result ); + FunctionType *function = getFunctionType( appExpr->function->result ); assert( function ); std::list< DeclarationWithType* >::iterator formal; std::list< Expression* >::iterator actual; for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) { - *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() ); - } - } - - Expression * Specialize::mutate( ApplicationExpr *appExpr ) { - appExpr->get_function()->acceptMutator( *this ); - mutateAll( appExpr->get_args(), *this ); - + *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() ); + } + } + + Expression * Specialize::postmutate( ApplicationExpr *appExpr ) { if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) { // create thunks for the inferred parameters @@ -331,19 +325,11 @@ } - Expression * Specialize::mutate( AddressExpr *addrExpr ) { - addrExpr->get_arg()->acceptMutator( *this ); - assert( addrExpr->has_result() ); - addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) ); - return addrExpr; - } - - Expression * Specialize::mutate( CastExpr *castExpr ) { - castExpr->get_arg()->acceptMutator( *this ); - if ( castExpr->get_result()->isVoid() ) { + Expression * Specialize::postmutate( CastExpr *castExpr ) { + if ( castExpr->result->isVoid() ) { // can't specialize if we don't have a return value return castExpr; } - Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() ); - if ( specialized != castExpr->get_arg() ) { + Expression *specialized = doSpecialization( castExpr->result, castExpr->arg, &castExpr->inferParams ); + if ( specialized != castExpr->arg ) { // assume here that the specialization incorporates the cast return specialized; @@ -353,22 +339,6 @@ } - // Removing these for now. Richard put these in for some reason, but it's not clear why. - // In particular, copy constructors produce a comma expression, and with this code the parts - // of that comma expression are not specialized, which causes problems. - - // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) { - // return logicalExpr; - // } - - // Expression * Specialize::mutate( ConditionalExpr *condExpr ) { - // return condExpr; - // } - - // Expression * Specialize::mutate( CommaExpr *commaExpr ) { - // return commaExpr; - // } - void convertSpecializations( std::list< Declaration* >& translationUnit ) { - Specialize spec; + PassVisitor spec; mutateAll( translationUnit, spec ); } Index: src/GenPoly/module.mk =================================================================== --- src/GenPoly/module.mk (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/GenPoly/module.mk (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -6,5 +6,5 @@ ## file "LICENCE" distributed with Cforall. ## -## module.mk -- +## module.mk -- ## ## Author : Richard C. Bilson @@ -17,10 +17,7 @@ SRC += GenPoly/Box.cc \ GenPoly/GenPoly.cc \ - GenPoly/PolyMutator.cc \ GenPoly/ScrubTyVars.cc \ GenPoly/Lvalue.cc \ GenPoly/Specialize.cc \ - GenPoly/CopyParams.cc \ GenPoly/FindFunction.cc \ - GenPoly/DeclMutator.cc \ GenPoly/InstantiateGeneric.cc Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/InitTweak/FixInit.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -36,7 +36,5 @@ #include "FixGlobalInit.h" // for fixGlobalInit #include "GenInit.h" // for genCtorDtor -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/GenPoly.h" // for getFunctionType -#include "GenPoly/PolyMutator.h" // for PolyMutator #include "InitTweak.h" // for getFunctionName, getCallArg #include "Parser/LinkageSpec.h" // for C, Spec, Cforall, isBuiltin @@ -46,5 +44,4 @@ #include "SymTab/Indexer.h" // for Indexer #include "SymTab/Mangler.h" // for Mangler -#include "SynTree/AddStmtVisitor.h" // for AddStmtVisitor #include "SynTree/Attribute.h" // for Attribute #include "SynTree/Constant.h" // for Constant @@ -58,5 +55,4 @@ #include "SynTree/TypeSubstitution.h" // for TypeSubstitution, operator<< #include "SynTree/Visitor.h" // for acceptAll, maybeAccept -#include "Tuples/Tuples.h" // for isTtype bool ctordtorp = false; // print all debug @@ -97,5 +93,5 @@ /// true if type does not need to be copy constructed to ensure correctness bool skipCopyConstruct( Type * type ); - void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ); + void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ); void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr ); @@ -187,5 +183,5 @@ }; - class FixCopyCtors final : public GenPoly::PolyMutator { + class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef { public: FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){} @@ -194,9 +190,7 @@ static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount ); - typedef GenPoly::PolyMutator Parent; - using Parent::mutate; - virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override; - virtual Expression * mutate( UniqueExpr * unqExpr ) override; - virtual Expression * mutate( StmtExpr * stmtExpr ) override; + Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ); + void premutate( StmtExpr * stmtExpr ); + void premutate( UniqueExpr * unqExpr ); UnqCount & unqCount; @@ -220,10 +214,10 @@ void emit( CodeLocation, const Params &... params ); - FunctionDecl * function = 0; + FunctionDecl * function = nullptr; std::set< DeclarationWithType * > unhandled; std::map< DeclarationWithType *, CodeLocation > usedUninit; - ObjectDecl * thisParam = 0; + ObjectDecl * thisParam = nullptr; bool isCtor = false; // true if current function is a constructor - StructDecl * structDecl = 0; + StructDecl * structDecl = nullptr; }; @@ -243,11 +237,9 @@ }; - class FixCtorExprs final : public GenPoly::DeclMutator { - public: + struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer { /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument static void fix( std::list< Declaration * > & translationUnit ); - using GenPoly::DeclMutator::mutate; - virtual Expression * mutate( ConstructorExpr * ctorExpr ) override; + Expression * postmutate( ConstructorExpr * ctorExpr ); }; } // namespace @@ -268,4 +260,5 @@ GenStructMemberCalls::generate( translationUnit ); + // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a // hack in the way untyped assignments are generated, where the first argument cannot have @@ -297,5 +290,5 @@ for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { try { - *i = maybeMutate( *i, fixer ); + maybeMutate( *i, fixer ); translationUnit.splice( i, fixer.pass.staticDtorDecls ); } catch( SemanticError &e ) { @@ -316,5 +309,5 @@ void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) { - FixCopyCtors fixer( unqCount ); + PassVisitor fixer( unqCount ); mutateAll( translationUnit, fixer ); } @@ -326,21 +319,19 @@ void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) { - FixCtorExprs fixer; - fixer.mutateDeclarationList( translationUnit ); + PassVisitor fixer; + mutateAll( translationUnit, fixer ); } Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) { - assert( appExpr ); - if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) { - if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) { + if ( function->var->linkage.is_builtin ) { // optimization: don't need to copy construct in order to call intrinsic functions return appExpr; } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) { FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) ); - assert( ftype ); - if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) { - Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); - Type * t2 = ftype->get_parameters().back()->get_type(); + assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() ); + if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->parameters.size() == 2 ) { + Type * t1 = getPointerBase( ftype->parameters.front()->get_type() ); + Type * t2 = ftype->parameters.back()->get_type(); assert( t1 ); @@ -368,7 +359,5 @@ } - bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { - return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type ); - } + bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); } Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) { @@ -377,11 +366,12 @@ ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg ); ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() ); - Expression * untyped = exprStmt->get_expr(); + Expression * resolved = exprStmt->expr; + exprStmt->expr = nullptr; // take ownership of expr // resolve copy constructor // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed // (VariableExpr and already resolved expression) - CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; ) - Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer ); + CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; ) + ResolvExpr::findVoidExpression( resolved, indexer ); assert( resolved ); if ( resolved->get_env() ) { @@ -391,21 +381,21 @@ resolved->set_env( nullptr ); } // if - delete stmt; return resolved; } - void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) { + void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ) { static UniqueName tempNamer("_tmp_cp"); assert( env ); CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; ) - assert( arg->has_result() ); - Type * result = arg->get_result(); + assert( arg->result ); + Type * result = arg->result; if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types - // type may involve type variables, so apply type substitution to get temporary variable's actual type + // type may involve type variables, so apply type substitution to get temporary variable's actual type. + // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T). result = result->clone(); - env->apply( result ); - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); + env->applyFree( result ); + ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr ); tmp->get_type()->set_const( false ); @@ -417,13 +407,19 @@ // if the chosen constructor is intrinsic, the copy is unnecessary, so // don't create the temporary and don't call the copy constructor - VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() ); - assert( function ); - if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return; - } + VariableExpr * function = strict_dynamic_cast< VariableExpr * >( appExpr->function ); + if ( function->var->linkage == LinkageSpec::Intrinsic ) { + // arguments that need to be boxed need a temporary regardless of whether the copy constructor is intrinsic, + // so that the object isn't changed inside of the polymorphic function + if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return; + } + } + + // set a unique name for the temporary once it's certain the call is necessary + tmp->name = tempNamer.newName(); // replace argument to function call with temporary arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) ); - impCpCtorExpr->get_tempDecls().push_back( tmp ); - impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) ); + impCpCtorExpr->tempDecls.push_back( tmp ); + impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) ); } @@ -435,9 +431,19 @@ CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; ) - ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr(); + ApplicationExpr * appExpr = impCpCtorExpr->callExpr; // take each argument and attempt to copy construct it. - for ( Expression * & arg : appExpr->get_args() ) { - copyConstructArg( arg, impCpCtorExpr ); + FunctionType * ftype = GenPoly::getFunctionType( appExpr->function->result ); + assert( ftype ); + auto & params = ftype->parameters; + auto iter = params.begin(); + for ( Expression * & arg : appExpr->args ) { + Type * formal = nullptr; + if ( iter != params.end() ) { + DeclarationWithType * param = *iter++; + formal = param->get_type(); + } + + copyConstructArg( arg, impCpCtorExpr, formal ); } // for @@ -445,15 +451,15 @@ // initialized with the return value and is destructed later // xxx - handle named return values? - Type * result = appExpr->get_result(); + Type * result = appExpr->result; if ( ! result->isVoid() ) { static UniqueName retNamer("_tmp_cp_ret"); result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); - ret->get_type()->set_const( false ); - impCpCtorExpr->get_returnDecls().push_back( ret ); + ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr ); + ret->type->set_const( false ); + impCpCtorExpr->returnDecls.push_back( ret ); CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; ) if ( ! dynamic_cast< ReferenceType * >( result ) ) { - // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary + // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary destructRet( ret, impCpCtorExpr ); } @@ -472,5 +478,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); + ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr ); ret->get_type()->set_const( false ); stmtExpr->get_returnDecls().push_front( ret ); @@ -493,4 +499,18 @@ visit_children = false; } + } + + // to prevent warnings (‘_unq0’ may be used uninitialized in this function), + // insert an appropriate zero initializer for UniqueExpr temporaries. + Initializer * makeInit( Type * t ) { + if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) { + // initizer for empty struct must be empty + if ( inst->baseStruct->members.empty() ) return new ListInit({}); + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) { + // initizer for empty union must be empty + if ( inst->baseUnion->members.empty() ) return new ListInit({}); + } + + return new ListInit( { new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) } ); } @@ -509,5 +529,5 @@ } else { // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression - unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) ); + unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), makeInit( unqExpr->get_result() ) ) ); unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) ); } @@ -515,8 +535,7 @@ } - Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) { + Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) { CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; ) - impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) ); std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls(); std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls(); @@ -525,8 +544,8 @@ // add all temporary declarations and their constructors for ( ObjectDecl * obj : tempDecls ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for for ( ObjectDecl * obj : returnDecls ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for @@ -536,5 +555,4 @@ } // for - // xxx - update to work with multiple return values ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front(); Expression * callExpr = impCpCtorExpr->get_callExpr(); @@ -561,6 +579,5 @@ Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) ); // move env from callExpr to retExpr - retExpr->set_env( callExpr->get_env() ); - callExpr->set_env( nullptr ); + std::swap( retExpr->env, callExpr->env ); return retExpr; } else { @@ -569,21 +586,23 @@ } - Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) { + void FixCopyCtors::premutate( StmtExpr * stmtExpr ) { // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression, // since temporaries can be shared across sub-expressions, e.g. // [A, A] f(); // g([A] x, [A] y); - // f(g()); + // g(f()); // f is executed once, so the return temporary is shared across the tuple constructors for x and y. + // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added + // to the outer context, rather than inside of the statement expression. + visit_children = false; std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids(); for ( Statement *& stmt : stmts ) { - stmt = stmt->acceptMutator( *this ); + stmt = stmt->acceptMutator( *visitor ); } // for - // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) ); assert( stmtExpr->get_result() ); Type * result = stmtExpr->get_result(); if ( ! result->isVoid() ) { for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for // add destructors after current statement @@ -592,8 +611,7 @@ } // for // must have a non-empty body, otherwise it wouldn't have a result - CompoundStmt * body = stmtExpr->get_statements(); - assert( ! body->get_kids().empty() ); + assert( ! stmts.empty() ); assert( ! stmtExpr->get_returnDecls().empty() ); - body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) ); + stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) ); stmtExpr->get_returnDecls().clear(); stmtExpr->get_dtors().clear(); @@ -601,12 +619,11 @@ assert( stmtExpr->get_returnDecls().empty() ); assert( stmtExpr->get_dtors().empty() ); - return stmtExpr; - } - - Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) { + } + + void FixCopyCtors::premutate( UniqueExpr * unqExpr ) { + visit_children = false; unqCount[ unqExpr->get_id() ]--; static std::unordered_map< int, std::list< Statement * > > dtors; static std::unordered_map< int, UniqueExpr * > unqMap; - static std::unordered_set< int > addDeref; // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes if ( unqMap.count( unqExpr->get_id() ) ) { @@ -619,33 +636,19 @@ stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] ); } - if ( addDeref.count( unqExpr->get_id() ) ) { - // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too - return UntypedExpr::createDeref( unqExpr ); - } - return unqExpr; - } - FixCopyCtors fixer( unqCount ); + return; + } + PassVisitor fixer( unqCount ); unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup - stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd ); + stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore ); unqMap[unqExpr->get_id()] = unqExpr; if ( unqCount[ unqExpr->get_id() ] == 0 ) { // insert destructor after the last use of the unique expression stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] ); } else { // remember dtors for last instance of unique expr - dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter; - } - if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) { - // unique expression is now a dereference, because the inner expression is an lvalue returning function call. - // Normalize the expression by dereferencing the unique expression, rather than the inner expression - // (i.e. move the dereference out a level) - assert( getFunctionName( deref ) == "*?" ); - unqExpr->set_expr( getCallArg( deref, 0 ) ); - getCallArg( deref, 0 ) = unqExpr; - addDeref.insert( unqExpr->get_id() ); - return deref; - } - return unqExpr; - } - - DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) { + dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter; + } + return; + } + + DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) { // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate) if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { @@ -745,22 +748,25 @@ } else { ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor ); - ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() ); + ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt ); ApplicationExpr * ctorCall = nullptr; - if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) { + if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) { // clean up intrinsic copy constructor calls by making them into SingleInits - objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) ); - ctorCall->get_args().pop_back(); + Expression * ctorArg = ctorCall->args.back(); + std::swap( ctorArg->env, ctorCall->env ); + objDecl->init = new SingleInit( ctorArg ); + + ctorCall->args.pop_back(); } else { stmtsToAddAfter.push_back( ctor ); - objDecl->set_init( nullptr ); - ctorInit->set_ctor( nullptr ); + objDecl->init = nullptr; + ctorInit->ctor = nullptr; } } // if - } else if ( Initializer * init = ctorInit->get_init() ) { - objDecl->set_init( init ); - ctorInit->set_init( nullptr ); + } else if ( Initializer * init = ctorInit->init ) { + objDecl->init = init; + ctorInit->init = nullptr; } else { // no constructor and no initializer, which is okay - objDecl->set_init( nullptr ); + objDecl->init = nullptr; } // if delete ctorInit; @@ -819,7 +825,9 @@ assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); Statement * dtor = ctorInit->get_dtor(); + // don't need to call intrinsic dtor, because it does nothing, but + // non-intrinsic dtors must be called if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) { - // don't need to call intrinsic dtor, because it does nothing, but - // non-intrinsic dtors must be called + // set dtor location to the object's location for error messages + ctorInit->dtor->location = objDecl->location; reverseDeclOrder.front().push_front( objDecl ); } // if @@ -832,4 +840,6 @@ GuardValue( labelVars ); labelVars.clear(); + // LabelFinder does not recurse into FunctionDecl, so need to visit + // its children manually. maybeAccept( funcDecl->type, finder ); maybeAccept( funcDecl->statements, finder ); @@ -933,6 +943,19 @@ } + void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) { + for ( auto d : decls ) { + indexer.addId( d ); + } + } + + void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) { + for ( auto td : tds ) { + indexer.addType( td ); + addIds( indexer, td->assertions ); + } + } + void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) { - GuardValue( funcDecl ); + GuardValue( function ); GuardValue( unhandled ); GuardValue( usedUninit ); @@ -967,17 +990,4 @@ } - void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) { - for ( auto d : decls ) { - indexer.addId( d ); - } - } - - void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) { - for ( auto td : tds ) { - indexer.addType( td ); - addIds( indexer, td->assertions ); - } - } - void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) { // remove the unhandled objects from usedUninit, because a call is inserted @@ -1012,4 +1022,6 @@ // skip non-DWT members if ( ! field ) continue; + // skip non-constructable members + if ( ! tryConstruct( field ) ) continue; // skip handled members if ( ! unhandled.count( field ) ) continue; @@ -1130,5 +1142,5 @@ } - DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) { + DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) { // add object to the indexer assumes that there will be no name collisions // in generated code. If this changes, add mutate methods for entities with @@ -1138,16 +1150,18 @@ } - Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) { - return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) ); - } - - Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) { + Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) { + Expression * newExpr = untypedExpr; + ResolvExpr::findVoidExpression( newExpr, indexer ); + return newExpr; + } + + Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) { static UniqueName tempNamer( "_tmp_ctor_expr" ); // xxx - is the size check necessary? - assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 ); + assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 ); // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary. - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr ); - addDeclaration( tmp ); + ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr ); + declsToAddBefore.push_back( tmp ); // xxx - this can be TupleAssignExpr now. Need to properly handle this case. @@ -1158,26 +1172,13 @@ delete ctorExpr; + // build assignment and replace constructor's first argument with new temporary Expression *& firstArg = callExpr->get_args().front(); - - // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away. - - // generate the type of assignment operator using the type of tmp minus any reference types - Type * type = tmp->get_type()->stripReferences(); - FunctionType * ftype = SymTab::genAssignType( type ); - - // generate fake assignment decl and call it using &tmp and &firstArg - // since tmp is guaranteed to be a reference and we want to assign pointers - FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr ); - ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) ); - assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) ); - Expression * addrArg = new AddressExpr( firstArg ); - // if firstArg has type T&&, then &firstArg has type T*&. - // Cast away the reference to a value type so that the argument - // matches the assignment's parameter types - if ( dynamic_cast( addrArg->get_result() ) ) { - addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() ); - } - assign->get_args().push_back( addrArg ); + Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } ); firstArg = new VariableExpr( tmp ); + + // resolve assignment and dispose of new env + ResolvExpr::findVoidExpression( assign, indexer ); + delete assign->env; + assign->env = nullptr; // for constructor expr: Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/InitTweak/GenInit.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -26,5 +26,4 @@ #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for ValueGuard, maybeClone -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/GenPoly.h" // for getFunctionType, isPolyType #include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::const_iter... @@ -62,5 +61,5 @@ }; - struct CtorDtor : public WithGuards, public WithShortCircuiting { + struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef { /// create constructor and destructor statements for object declarations. /// the actual call statements will be added in after the resolver has run @@ -75,10 +74,7 @@ // that need to be constructed or destructed void previsit( StructDecl *aggregateDecl ); - void previsit( __attribute__((unused)) UnionDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) EnumDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TraitDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TypeDecl * typeDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TypedefDecl * typeDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) FunctionType * funcType ) { visit_children = false; } + void previsit( AggregateDecl * ) { visit_children = false; } + void previsit( NamedTypeDecl * ) { visit_children = false; } + void previsit( FunctionType * ) { visit_children = false; } void previsit( CompoundStmt * compoundStmt ); @@ -89,15 +85,9 @@ // should not have a ConstructorInit generated. - bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed - bool isManaged( Type * type ) const; // determine if type is managed - void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor - GenPoly::ScopedSet< std::string > managedTypes; + ManagedTypes managedTypes; bool inFunction = false; }; - class HoistArrayDimension final : public GenPoly::DeclMutator { - public: - typedef GenPoly::DeclMutator Parent; - + struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards { /// hoist dimension from array types in object declaration so that it uses a single /// const variable of type size_t, so that side effecting array dimensions are only @@ -105,19 +95,12 @@ static void hoistArrayDimension( std::list< Declaration * > & translationUnit ); - private: - using Parent::mutate; - - virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override; - virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override; + void premutate( ObjectDecl * objectDecl ); + DeclarationWithType * postmutate( ObjectDecl * objectDecl ); + void premutate( FunctionDecl *functionDecl ); // should not traverse into any of these declarations to find objects // that need to be constructed or destructed - virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; } - virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; } - virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; } - - virtual Type* mutate( FunctionType *funcType ) override { return funcType; } + void premutate( AggregateDecl * ) { visit_children = false; } + void premutate( NamedTypeDecl * ) { visit_children = false; } + void premutate( FunctionType * ) { visit_children = false; } void hoist( Type * type ); @@ -128,10 +111,10 @@ void genInit( std::list< Declaration * > & translationUnit ) { - ReturnFixer::makeReturnTemp( translationUnit ); + fixReturnStatements( translationUnit ); HoistArrayDimension::hoistArrayDimension( translationUnit ); CtorDtor::generateCtorDtor( translationUnit ); } - void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) { + void fixReturnStatements( std::list< Declaration * > & translationUnit ) { PassVisitor fixer; mutateAll( translationUnit, fixer ); @@ -143,12 +126,17 @@ // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address // is being returned - if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) { + if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) { // explicitly construct the return value using the return expression and the retVal object - assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() ); - - stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) ); + assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() ); + + ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() ); + if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) { + // return statement has already been mutated - don't need to do it again + if ( varExpr->var == retVal ) return; + } + stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) ); // return the retVal object - returnStmt->set_expr( new VariableExpr( returnVals.front() ) ); + returnStmt->expr = new VariableExpr( returnVals.front() ); } // if } @@ -158,6 +146,6 @@ GuardValue( funcName ); - ftype = functionDecl->get_functionType(); - funcName = functionDecl->get_name(); + ftype = functionDecl->type; + funcName = functionDecl->name; } @@ -165,13 +153,16 @@ // which would be incorrect if it is a side-effecting computation. void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) { - HoistArrayDimension hoister; - hoister.mutateDeclarationList( translationUnit ); - } - - DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) { + PassVisitor hoister; + mutateAll( translationUnit, hoister ); + } + + void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) { + GuardValue( storageClasses ); storageClasses = objectDecl->get_storageClasses(); - DeclarationWithType * temp = Parent::mutate( objectDecl ); + } + + DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) { hoist( objectDecl->get_type() ); - return temp; + return objectDecl; } @@ -194,5 +185,5 @@ arrayType->set_dimension( new VariableExpr( arrayDimension ) ); - addDeclaration( arrayDimension ); + declsToAddBefore.push_back( arrayDimension ); hoist( arrayType->get_base() ); @@ -201,9 +192,6 @@ } - DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) { - ValueGuard< bool > oldInFunc( inFunction ); - inFunction = true; - DeclarationWithType * decl = Parent::mutate( functionDecl ); - return decl; + void HoistArrayDimension::premutate( FunctionDecl * ) { + GuardValue( inFunction ); } @@ -213,6 +201,6 @@ } - bool CtorDtor::isManaged( Type * type ) const { - // at least for now, references are never constructed + bool ManagedTypes::isManaged( Type * type ) const { + // references are never constructed if ( dynamic_cast< ReferenceType * >( type ) ) return false; // need to clear and reset qualifiers when determining if a type is managed @@ -221,13 +209,13 @@ if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) { // tuple is also managed if any of its components are managed - if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) { + if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) { return true; } } // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable) - return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() || GenPoly::isPolyType( type ); - } - - bool CtorDtor::isManaged( ObjectDecl * objDecl ) const { + return managedTypes.find( SymTab::Mangler::mangleConcrete( type ) ) != managedTypes.end() || GenPoly::isPolyType( type ); + } + + bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const { Type * type = objDecl->get_type(); while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { @@ -237,5 +225,5 @@ } - void CtorDtor::handleDWT( DeclarationWithType * dwt ) { + void ManagedTypes::handleDWT( DeclarationWithType * dwt ) { // if this function is a user-defined constructor or destructor, mark down the type as "managed" if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) { @@ -244,7 +232,26 @@ Type * type = InitTweak::getPointerBase( params.front()->get_type() ); assert( type ); - managedTypes.insert( SymTab::Mangler::mangle( type ) ); - } - } + managedTypes.insert( SymTab::Mangler::mangleConcrete( type ) ); + } + } + + void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) { + // don't construct members, but need to take note if there is a managed member, + // because that means that this type is also managed + for ( Declaration * member : aggregateDecl->get_members() ) { + if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) { + if ( isManaged( field ) ) { + // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that + // polymorphic constructors make generic types managed types + StructInstType inst( Type::Qualifiers(), aggregateDecl ); + managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) ); + break; + } + } + } + } + + void ManagedTypes::beginScope() { managedTypes.beginScope(); } + void ManagedTypes::endScope() { managedTypes.endScope(); } ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) { @@ -291,8 +298,8 @@ void CtorDtor::previsit( ObjectDecl * objDecl ) { - handleDWT( objDecl ); + managedTypes.handleDWT( objDecl ); // hands off if @=, extern, builtin, etc. // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C - if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) { + if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) { // constructed objects cannot be designated if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl ); @@ -305,8 +312,9 @@ void CtorDtor::previsit( FunctionDecl *functionDecl ) { + visit_children = false; // do not try and construct parameters or forall parameters GuardValue( inFunction ); inFunction = true; - handleDWT( functionDecl ); + managedTypes.handleDWT( functionDecl ); GuardScope( managedTypes ); @@ -314,12 +322,9 @@ for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) { for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) { - handleDWT( assertion ); + managedTypes.handleDWT( assertion ); } } - PassVisitor newCtorDtor; - newCtorDtor.pass = *this; - maybeAccept( functionDecl->get_statements(), newCtorDtor ); - visit_children = false; // do not try and construct parameters or forall parameters - must happen after maybeAccept + maybeAccept( functionDecl->get_statements(), *visitor ); } @@ -327,18 +332,8 @@ visit_children = false; // do not try to construct and destruct aggregate members - // don't construct members, but need to take note if there is a managed member, - // because that means that this type is also managed - for ( Declaration * member : aggregateDecl->get_members() ) { - if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) { - if ( isManaged( field ) ) { - StructInstType inst( Type::Qualifiers(), aggregateDecl ); - managedTypes.insert( SymTab::Mangler::mangle( &inst ) ); - break; - } - } - } - } - - void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) { + managedTypes.handleStruct( aggregateDecl ); + } + + void CtorDtor::previsit( CompoundStmt * ) { GuardScope( managedTypes ); } Index: src/InitTweak/GenInit.h =================================================================== --- src/InitTweak/GenInit.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/InitTweak/GenInit.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -16,8 +16,10 @@ #pragma once -#include // for list -#include // for string +#include // for list +#include // for string -#include "SynTree/SynTree.h" // for Visitor Nodes +#include "SynTree/SynTree.h" // for Visitor Nodes + +#include "GenPoly/ScopedSet.h" // for ScopedSet namespace InitTweak { @@ -25,9 +27,26 @@ void genInit( std::list< Declaration * > & translationUnit ); - /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument - ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr ); + /// Converts return statements into copy constructor calls on the hidden return variable + void fixReturnStatements( std::list< Declaration * > & translationUnit ); + + /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument + ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr ); /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer ConstructorInit * genCtorInit( ObjectDecl * objDecl ); + + class ManagedTypes { + public: + bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed + bool isManaged( Type * type ) const; // determine if type is managed + + void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor + void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed + + void beginScope(); + void endScope(); + private: + GenPoly::ScopedSet< std::string > managedTypes; + }; } // namespace Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/InitTweak/InitTweak.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -1,3 +1,2 @@ -#include // for NULL #include // for find, all_of #include // for assertf, assert, strict_dynamic_cast @@ -23,4 +22,5 @@ #include "SynTree/Type.h" // for FunctionType, ArrayType, PointerType #include "SynTree/Visitor.h" // for Visitor, maybeAccept +#include "Tuples/Tuples.h" // for Tuples::isTtype class UntypedValofExpr; @@ -170,4 +170,13 @@ } + bool InitExpander::addReference() { + bool added = false; + for ( Expression *& expr : cur ) { + expr = new AddressExpr( expr ); + added = true; + } + return added; + } + namespace { /// given index i, dimension d, initializer init, and callExpr f, generates @@ -184,5 +193,5 @@ callExpr->get_args().splice( callExpr->get_args().end(), args ); - *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL ); + *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr ); UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) ); @@ -250,18 +259,18 @@ // To accomplish this, generate switch statement, consuming all of expander's elements Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) { - if ( ! init ) return NULL; + if ( ! init ) return nullptr; CompoundStmt * block = new CompoundStmt( noLabels ); build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) ); if ( block->get_kids().empty() ) { delete block; - return NULL; + return nullptr; } else { - init = NULL; // init was consumed in creating the list init + init = nullptr; // init was consumed in creating the list init return block; } } - Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) { - return NULL; + Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) { + return nullptr; } @@ -270,9 +279,30 @@ } - bool tryConstruct( ObjectDecl * objDecl ) { + Type * getTypeofThis( FunctionType * ftype ) { + assertf( ftype, "getTypeofThis: nullptr ftype" ); + ObjectDecl * thisParam = getParamThis( ftype ); + ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type ); + return refType->base; + } + + ObjectDecl * getParamThis( FunctionType * ftype ) { + assertf( ftype, "getParamThis: nullptr ftype" ); + auto & params = ftype->parameters; + assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() ); + return strict_dynamic_cast< ObjectDecl * >( params.front() ); + } + + bool tryConstruct( DeclarationWithType * dwt ) { + ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt ); + if ( ! objDecl ) return false; return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) && - (objDecl->get_init() == NULL || - ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) - && ! objDecl->get_storageClasses().is_extern; + (objDecl->get_init() == nullptr || + ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() )) + && ! objDecl->get_storageClasses().is_extern + && isConstructable( objDecl->type ); + } + + bool isConstructable( Type * type ) { + return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type ); } @@ -314,5 +344,5 @@ collectCtorDtorCalls( stmt, matches ); assert( matches.size() <= 1 ); - return matches.size() == 1 ? matches.front() : NULL; + return matches.size() == 1 ? matches.front() : nullptr; } @@ -332,9 +362,9 @@ assert( expr ); if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { - return varExpr->get_var(); + return varExpr->var; } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) { - return memberExpr->get_member(); + return memberExpr->member; } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { - return getCalledFunction( castExpr->get_arg() ); + return getCalledFunction( castExpr->arg ); } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) { return handleDerefCalledFunction( untypedExpr ); @@ -342,5 +372,7 @@ return handleDerefCalledFunction( appExpr ); } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) { - return getCalledFunction( addrExpr->get_arg() ); + return getCalledFunction( addrExpr->arg ); + } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) { + return getCalledFunction( commaExpr->arg2 ); } return nullptr; @@ -359,10 +391,10 @@ ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) { ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ); - if ( ! appExpr ) return NULL; + if ( ! appExpr ) return nullptr; DeclarationWithType * function = getCalledFunction( appExpr->get_function() ); assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() ); // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor // will call all member dtors, and some members may have a user defined dtor. - return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL; + return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr; } @@ -482,5 +514,5 @@ return refType->get_base(); } else { - return NULL; + return nullptr; } } @@ -488,5 +520,5 @@ Type * isPointerType( Type * type ) { if ( getPointerBase( type ) ) return type; - else return NULL; + else return nullptr; } @@ -557,11 +589,11 @@ FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) { FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ); - if ( ! function ) return 0; - if ( function->get_name() != fname ) return 0; - FunctionType * ftype = function->get_functionType(); - if ( ftype->get_parameters().size() != 2 ) return 0; + if ( ! function ) return nullptr; + if ( function->name != fname ) return nullptr; + FunctionType * ftype = function->type; + if ( ftype->parameters.size() != 2 ) return nullptr; Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); - Type * t2 = ftype->get_parameters().back()->get_type(); + Type * t2 = ftype->parameters.back()->get_type(); assert( t1 ); @@ -583,7 +615,7 @@ } FunctionDecl * isDefaultConstructor( Declaration * decl ) { - if ( isConstructor( decl->get_name() ) ) { + if ( isConstructor( decl->name ) ) { if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) { - if ( func->get_functionType()->get_parameters().size() == 1 ) { + if ( func->type->parameters.size() == 1 ) { return func; } Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/InitTweak/InitTweak.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -30,9 +30,18 @@ FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ); + /// returns the base type of the first parameter to a constructor/destructor/assignment function + Type * getTypeofThis( FunctionType * ftype ); + + /// returns the first parameter of a constructor/destructor/assignment function + ObjectDecl * getParamThis( FunctionType * ftype ); + /// transform Initializer into an argument list that can be passed to a call expression std::list< Expression * > makeInitList( Initializer * init ); - /// True if the resolver should try to construct objDecl - bool tryConstruct( ObjectDecl * objDecl ); + /// True if the resolver should try to construct dwt + bool tryConstruct( DeclarationWithType * dwt ); + + /// True if the type can have a user-defined constructor + bool isConstructable( Type * t ); /// True if the Initializer contains designations @@ -96,4 +105,5 @@ void addArrayIndex( Expression * index, Expression * dimension ); void clearArrayIndices(); + bool addReference(); class ExpanderImpl; Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/MakeLibCfa.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -119,4 +119,5 @@ newDecls.push_back( funcDecl ); + Statement * stmt = nullptr; switch ( opInfo.type ) { case CodeGen::OT_INDEX: @@ -128,8 +129,11 @@ case CodeGen::OT_POSTFIXASSIGN: case CodeGen::OT_INFIXASSIGN: + // return the recursive call + stmt = new ReturnStmt( noLabels, newExpr ); + break; case CodeGen::OT_CTOR: case CodeGen::OT_DTOR: - // return the recursive call - funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); + // execute the recursive call + stmt = new ExprStmt( noLabels, newExpr ); break; case CodeGen::OT_CONSTANT: @@ -138,4 +142,5 @@ assert( false ); } // switch + funcDecl->get_statements()->push_back( stmt ); } } // namespace Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Makefile.in (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -172,11 +172,8 @@ GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \ GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \ GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \ GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \ GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \ GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \ GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \ InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \ @@ -253,5 +250,4 @@ SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \ - SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \ SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \ @@ -497,32 +493,30 @@ ControlStruct/ForExprMutator.cc \ ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \ - GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \ - GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \ - GenPoly/CopyParams.cc GenPoly/FindFunction.cc \ - GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \ - InitTweak/GenInit.cc InitTweak/FixInit.cc \ - InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \ - Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \ - Parser/ParseNode.cc Parser/DeclarationNode.cc \ - Parser/ExpressionNode.cc Parser/StatementNode.cc \ - Parser/InitializerNode.cc Parser/TypeData.cc \ - Parser/LinkageSpec.cc Parser/parserutility.cc \ - ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \ - ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \ - ResolvExpr/CommonType.cc ResolvExpr/ConversionCost.cc \ - ResolvExpr/CastCost.cc ResolvExpr/PtrsCastable.cc \ - ResolvExpr/AdjustExprType.cc ResolvExpr/AlternativePrinter.cc \ - ResolvExpr/Resolver.cc ResolvExpr/ResolveTypeof.cc \ - ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \ - ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \ - SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \ - SymTab/FixFunction.cc SymTab/ImplementationType.cc \ - SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \ - SynTree/VoidType.cc SynTree/BasicType.cc \ - SynTree/PointerType.cc SynTree/ArrayType.cc \ - SynTree/ReferenceType.cc SynTree/FunctionType.cc \ - SynTree/ReferenceToType.cc SynTree/TupleType.cc \ - SynTree/TypeofType.cc SynTree/AttrType.cc \ + GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \ + GenPoly/Specialize.cc GenPoly/FindFunction.cc \ + GenPoly/InstantiateGeneric.cc InitTweak/GenInit.cc \ + InitTweak/FixInit.cc InitTweak/FixGlobalInit.cc \ + InitTweak/InitTweak.cc Parser/parser.yy Parser/lex.ll \ + Parser/TypedefTable.cc Parser/ParseNode.cc \ + Parser/DeclarationNode.cc Parser/ExpressionNode.cc \ + Parser/StatementNode.cc Parser/InitializerNode.cc \ + Parser/TypeData.cc Parser/LinkageSpec.cc \ + Parser/parserutility.cc ResolvExpr/AlternativeFinder.cc \ + ResolvExpr/Alternative.cc ResolvExpr/Unify.cc \ + ResolvExpr/PtrsAssignable.cc ResolvExpr/CommonType.cc \ + ResolvExpr/ConversionCost.cc ResolvExpr/CastCost.cc \ + ResolvExpr/PtrsCastable.cc ResolvExpr/AdjustExprType.cc \ + ResolvExpr/AlternativePrinter.cc ResolvExpr/Resolver.cc \ + ResolvExpr/ResolveTypeof.cc ResolvExpr/RenameVars.cc \ + ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \ + ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \ + ResolvExpr/CurrentObject.cc SymTab/Indexer.cc \ + SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \ + SymTab/ImplementationType.cc SymTab/TypeEquality.cc \ + SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \ + SynTree/BasicType.cc SynTree/PointerType.cc \ + SynTree/ArrayType.cc SynTree/ReferenceType.cc \ + SynTree/FunctionType.cc SynTree/ReferenceToType.cc \ + SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \ SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \ SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \ @@ -535,8 +529,8 @@ SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \ SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \ - SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \ - SynTree/Attribute.cc SynTree/VarExprReplacer.cc \ - Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \ - Tuples/Explode.cc Virtual/ExpandCasts.cc + SynTree/TypeSubstitution.cc SynTree/Attribute.cc \ + SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \ + Tuples/TupleExpansion.cc Tuples/Explode.cc \ + Virtual/ExpandCasts.cc MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \ ${cfa_cpplib_PROGRAMS}} @@ -717,6 +711,4 @@ GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \ GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ - GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \ GenPoly/$(DEPDIR)/$(am__dirstamp) @@ -725,10 +717,6 @@ GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT): GenPoly/$(am__dirstamp) \ GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT): GenPoly/$(am__dirstamp) \ - GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT): \ GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ - GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT): \ GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) @@ -929,6 +917,4 @@ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) -SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT): \ - SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT): \ SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) @@ -1007,11 +993,8 @@ @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@ @@ -1056,5 +1039,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@ @@ -1450,18 +1432,4 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi` -GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc - -GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi` - GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc @@ -1506,18 +1474,4 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-Specialize.obj `if test -f 'GenPoly/Specialize.cc'; then $(CYGPATH_W) 'GenPoly/Specialize.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/Specialize.cc'; fi` -GenPoly/driver_cfa_cpp-CopyParams.o: GenPoly/CopyParams.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-CopyParams.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc - -GenPoly/driver_cfa_cpp-CopyParams.obj: GenPoly/CopyParams.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-CopyParams.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi` - GenPoly/driver_cfa_cpp-FindFunction.o: GenPoly/FindFunction.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-FindFunction.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Tpo -c -o GenPoly/driver_cfa_cpp-FindFunction.o `test -f 'GenPoly/FindFunction.cc' || echo '$(srcdir)/'`GenPoly/FindFunction.cc @@ -1534,18 +1488,4 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi` -GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc - -GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi` - GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc @@ -2583,18 +2523,4 @@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi` - -SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc - -SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi` SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/DeclarationNode.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 12:34:05 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 10 17:02:00 2017 -// Update Count : 1021 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Sep 23 18:16:48 2017 +// Update Count : 1024 // @@ -40,6 +40,6 @@ using namespace std; -// These must remain in the same order as the corresponding DeclarationNode enumerations. -const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" }; +// These must harmonize with the corresponding DeclarationNode enumerations. +const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" }; const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" }; const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" }; @@ -1031,8 +1031,9 @@ if ( variable.tyClass != NoTypeClass ) { - static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype }; - assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." ); + // otype is internally converted to dtype + otype parameters + static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype }; + assertf( sizeof(kindMap)/sizeof(kindMap[0]) == NoTypeClass, "DeclarationNode::build: kindMap is out of sync." ); assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." ); - TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.initializer ? variable.initializer->buildType() : nullptr ); + TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == Otype, variable.initializer ? variable.initializer->buildType() : nullptr ); buildList( variable.assertions, ret->get_assertions() ); return ret; Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/ExpressionNode.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:09:34 2017 -// Update Count : 690 +// Last Modified On : Wed Sep 27 22:51:55 2017 +// Update Count : 781 // @@ -60,4 +60,37 @@ static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } +static const char * lnthsInt[2][6] = { + { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", }, + { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", } +}; // lnthsInt + +static inline void checkLNInt( string & str, int & lnth, int & size ) { + string::size_type posn = str.find_first_of( "lL" ), start = posn; + if ( posn == string::npos ) return; + size = 4; // assume largest size + posn += 1; // advance to size + if ( str[posn] == '8' ) { // 8 + lnth = 0; + } else if ( str[posn] == '1' ) { + posn += 1; + if ( str[posn] == '6' ) { // 16 + lnth = 1; + } else { // 128 + posn += 1; + lnth = 5; + } // if + } else { + if ( str[posn] == '3' ) { // 32 + lnth = 2; + } else if ( str[posn] == '6' ) { // 64 + lnth = 3; + } else { + assertf( false, "internal error, bad integral length %s", str.c_str() ); + } // if + posn += 1; + } // if + str.erase( start, posn - start + 1 ); // remove length suffix +} // checkLNInt + static void sepNumeric( string & str, string & units ) { string::size_type posn = str.find_first_of( "`" ); @@ -69,15 +102,17 @@ Expression * build_constantInteger( string & str ) { - static const BasicType::Kind kind[2][5] = { + static const BasicType::Kind kind[2][6] = { // short (h) must be before char (hh) - { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, - { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt }, + { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, }, + { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, }, }; - string units; // units + string units; sepNumeric( str, units ); // separate constant from units bool dec = true, Unsigned = false; // decimal, unsigned constant - int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t + int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128 + int lnth = -1; // literal length + unsigned long long int v; // converted integral value size_t last = str.length() - 1; // last character of constant @@ -140,4 +175,6 @@ } // if str.erase( last - size - 1, size + 1 ); // remove 'h'/"hh" + } else { // suffix "ln" ? + checkLNInt( str, lnth, size ); } // if } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? @@ -163,14 +200,23 @@ str.erase( last - size, size + 1 ); // remove 'h'/"hh" } else if ( checkZ( str[last] ) ) { // suffix 'z' ? - size = 5; + lnth = 4; str.erase( last, 1 ); // remove 'z' - } // if - + } else { // suffix "ln" ? + checkLNInt( str, lnth, size ); + } // if + + assert( 0 <= size && size < 6 ); + // Constant type is correct for overload resolving. ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); - if ( Unsigned && size < 2 ) { // less than int ? - // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values. + if ( Unsigned && size < 2 ) { // hh or h, less than int ? + // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values. ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) ); - } else if ( size == 5 ) { // explicit cast to size_t - ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) ); + } else if ( lnth != -1 ) { // explicit length ? + if ( lnth == 5 ) { // int128 ? + size = 5; + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) ); + } else { + ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) ); + } // if } // if CLEANUP: @@ -182,4 +228,26 @@ return ret; } // build_constantInteger + + +static inline void checkLNFloat( string & str, int & lnth, int & size ) { + string::size_type posn = str.find_first_of( "lL" ), start = posn; + if ( posn == string::npos ) return; + size = 2; // assume largest size + lnth = 0; + posn += 1; // advance to size + if ( str[posn] == '3' ) { // 32 + size = 0; + } else if ( str[posn] == '6' ) { // 64 + size = 1; + } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128 + size = 2; + if ( str[posn] == '1' ) posn += 1; + } else { + assertf( false, "internal error, bad floating point length %s", str.c_str() ); + } // if + posn += 1; + str.erase( start, posn - start + 1 ); // remove length suffix +} // checkLNFloat + Expression * build_constantFloat( string & str ) { @@ -189,9 +257,10 @@ }; - string units; // units + string units; sepNumeric( str, units ); // separate constant from units bool complx = false; // real, complex - int size = 1; // 0 => float, 1 => double (default), 2 => long double + int size = 1; // 0 => float, 1 => double, 2 => long double + int lnth = -1; // literal length // floating-point constant has minimum of 2 characters: 1. or .1 size_t last = str.length() - 1; @@ -211,4 +280,7 @@ } else if ( checkL( str[last] ) ) { // long double ? size = 2; + } else { + size = 1; // double (default) + checkLNFloat( str, lnth, size ); } // if if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? @@ -216,5 +288,9 @@ } // if + assert( 0 <= size && size < 3 ); Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) ); + if ( lnth != -1 ) { // explicit length ? + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) ); + } // if if ( units.length() != 0 ) { ret = new UntypedExpr( new NameExpr( units ), { ret } ); @@ -321,5 +397,5 @@ NameExpr * build_varref( const string * name ) { - NameExpr * expr = new NameExpr( *name, nullptr ); + NameExpr * expr = new NameExpr( *name ); delete name; return expr; @@ -412,5 +488,5 @@ list< Expression * > args; buildMoveList( expr_node, args ); - return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr ); + return new UntypedExpr( maybeMoveBuild< Expression >(function), args ); } // build_func Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/ParseNode.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:09:39 2017 -// Update Count : 815 +// Last Modified On : Sat Sep 23 18:11:22 2017 +// Update Count : 821 // @@ -47,6 +47,4 @@ #define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */ -extern char * yyfilename; -extern int yylineno; extern YYLTYPE yylloc; @@ -197,18 +195,18 @@ class DeclarationNode : public ParseNode { public: - enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; + // These enumerations must harmonize with their names. + enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType }; + static const char * basicTypeNames[]; enum ComplexType { Complex, Imaginary, NoComplexType }; + static const char * complexTypeNames[]; enum Signedness { Signed, Unsigned, NoSignedness }; + static const char * signednessNames[]; enum Length { Short, Long, LongLong, NoLength }; + static const char * lengthNames[]; enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate }; + static const char * aggregateNames[]; enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass }; + static const char * typeClassNames[]; enum BuiltinType { Valist, Zero, One, NoBuiltinType }; - - static const char * basicTypeNames[]; - static const char * complexTypeNames[]; - static const char * signednessNames[]; - static const char * lengthNames[]; - static const char * aggregateNames[]; - static const char * typeClassNames[]; static const char * builtinTypeNames[]; Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/StatementNode.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -234,5 +234,5 @@ target, maybeMoveBuild( stmt ), - maybeMoveBuild( when ) + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -250,8 +250,8 @@ delete targetExpr; - node->clauses.push_back( WaitForStmt::Clause{ + node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{ std::move( target ), maybeMoveBuild( stmt ), - maybeMoveBuild( when ) + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -265,9 +265,9 @@ node->timeout.time = maybeMoveBuild( timeout ); node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = maybeMoveBuild( when ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); } else { - node->orelse.statement = maybeMoveBuild( stmt ); - node->orelse.condition = maybeMoveBuild( when ); + node->orelse.statement = maybeMoveBuild( stmt ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( when ) ); } @@ -280,17 +280,11 @@ node->timeout.time = maybeMoveBuild( timeout ); node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = maybeMoveBuild( when ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); node->orelse.statement = maybeMoveBuild( else_stmt ); - node->orelse.condition = maybeMoveBuild( else_when ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( else_when ) ); return node; } - -// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) { -// return WaitForStmt::Clause{ - -// }; -// } Statement *build_compound( StatementNode *first ) { Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/TypeData.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 1 23:13:38 2017 -// Update Count : 569 +// Last Modified On : Mon Sep 25 18:33:41 2017 +// Update Count : 587 // @@ -98,4 +98,5 @@ } // TypeData::TypeData + TypeData::~TypeData() { delete base; @@ -161,4 +162,5 @@ } // switch } // TypeData::~TypeData + TypeData * TypeData::clone() const { @@ -235,4 +237,5 @@ } // TypeData::clone + void TypeData::print( ostream &os, int indent ) const { for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) { @@ -399,10 +402,12 @@ } // TypeData::print + template< typename ForallList > void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) { buildList( firstNode, outputList ); - for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) { + auto n = firstNode; + for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) { TypeDecl * td = static_cast(*i); - if ( td->get_kind() == TypeDecl::Any ) { + if ( n->variable.tyClass == DeclarationNode::Otype ) { // add assertion parameters to `type' tyvars in reverse order // add dtor: void ^?{}(T *) @@ -430,5 +435,6 @@ } // if } // for -} +} // buildForall + Type * typebuild( const TypeData * td ) { @@ -477,4 +483,5 @@ } // typebuild + TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) { TypeData * ret = nullptr; @@ -504,8 +511,14 @@ } // typeextractAggregate + Type::Qualifiers buildQualifiers( const TypeData * td ) { return td->qualifiers; } // buildQualifiers + +static string genTSError( string msg, DeclarationNode::BasicType basictype ) { + throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." ); +} // genTSError + Type * buildBasicType( const TypeData * td ) { BasicType::Kind ret; @@ -513,8 +526,10 @@ switch ( td->basictype ) { case DeclarationNode::Void: - if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) { - throw SemanticError( "invalid type specifier \"void\" in type: ", td ); - } // if - + if ( td->signedness != DeclarationNode::NoSignedness ) { + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); + } // if + if ( td->length != DeclarationNode::NoLength ) { + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); + } // if return new VoidType( buildQualifiers( td ) ); break; @@ -522,8 +537,8 @@ case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); } // if if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if @@ -538,5 +553,5 @@ if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if @@ -557,5 +572,14 @@ break; + case DeclarationNode::Int128: + ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128; + if ( td->length != DeclarationNode::NoLength ) { + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); + } // if + break; + case DeclarationNode::Float: + case DeclarationNode::Float80: + case DeclarationNode::Float128: case DeclarationNode::Double: case DeclarationNode::LongDouble: // not set until below @@ -568,11 +592,11 @@ FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); } // if if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { - throw SemanticError( "invalid type specifier \"long\" in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if if ( td->length == DeclarationNode::Long ) { @@ -593,5 +617,5 @@ goto Integral; default: - assert(false); + assertf( false, "unknown basic type" ); return nullptr; } // switch @@ -601,4 +625,5 @@ return bt; } // buildBasicType + PointerType * buildPointer( const TypeData * td ) { @@ -612,4 +637,5 @@ return pt; } // buildPointer + ArrayType * buildArray( const TypeData * td ) { @@ -626,4 +652,5 @@ } // buildArray + ReferenceType * buildReference( const TypeData * td ) { ReferenceType * rt; @@ -637,4 +664,5 @@ } // buildReference + AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Aggregate ); @@ -665,4 +693,5 @@ return at; } // buildAggregate + ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { @@ -722,4 +751,5 @@ } // buildAggInst + ReferenceToType * buildAggInst( const TypeData * td ) { assert( td->kind == TypeData::AggregateInst ); @@ -761,4 +791,5 @@ } // buildAggInst + NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Symbolic ); @@ -768,5 +799,5 @@ ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage ); } else { - ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any ); + ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true ); } // if buildList( td->symbolic.params, ret->get_parameters() ); @@ -774,4 +805,5 @@ return ret; } // buildSymbolic + EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { @@ -790,4 +822,5 @@ } // buildEnum + TypeInstType * buildSymbolicInst( const TypeData * td ) { assert( td->kind == TypeData::SymbolicInst ); @@ -797,4 +830,5 @@ return ret; } // buildSymbolicInst + TupleType * buildTuple( const TypeData * td ) { @@ -807,4 +841,5 @@ } // buildTuple + TypeofType * buildTypeof( const TypeData * td ) { assert( td->kind == TypeData::Typeof ); @@ -813,4 +848,5 @@ return new TypeofType( buildQualifiers( td ), td->typeexpr->build() ); } // buildTypeof + Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) { @@ -836,4 +872,5 @@ return nullptr; } // buildDecl + FunctionType * buildFunction( const TypeData * td ) { @@ -857,4 +894,5 @@ return ft; } // buildFunction + // Transform KR routine declarations into C99 routine declarations: Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/lex.ll (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Sun Sep 10 22:29:15 2017 - * Update Count : 620 + * Last Modified On : Wed Oct 25 13:53:56 2017 + * Update Count : 634 */ @@ -93,5 +93,6 @@ // numeric constants, CFA: '_' in constant hex_quad {hex}("_"?{hex}){3} -length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH]) +size_opt (8|16|32|64|128)? +length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH]) integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt} @@ -109,5 +110,7 @@ // GCC: D (double) and iI (imaginary) suffixes, and DL (long double) exponent "_"?[eE]"_"?[+-]?{decimal_digits} -floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD]) +floating_size 32|64|80|128 +floating_length ([fFdDlL]|[lL]{floating_size}) +floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length}) floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt} decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal}) @@ -230,9 +233,12 @@ __extension__ { KEYWORD_RETURN(EXTENSION); } // GCC extern { KEYWORD_RETURN(EXTERN); } -fallthrough { KEYWORD_RETURN(FALLTHRU); } // CFA fallthru { KEYWORD_RETURN(FALLTHRU); } // CFA +fallthrough { KEYWORD_RETURN(FALLTHROUGH); } // CFA finally { KEYWORD_RETURN(FINALLY); } // CFA float { KEYWORD_RETURN(FLOAT); } -__float128 { KEYWORD_RETURN(FLOAT); } // GCC +__float80 { KEYWORD_RETURN(FLOAT80); } // GCC +float80 { KEYWORD_RETURN(FLOAT80); } // GCC +__float128 { KEYWORD_RETURN(FLOAT128); } // GCC +float128 { KEYWORD_RETURN(FLOAT128); } // GCC for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA @@ -249,6 +255,6 @@ __inline__ { KEYWORD_RETURN(INLINE); } // GCC int { KEYWORD_RETURN(INT); } -__int128 { KEYWORD_RETURN(INT); } // GCC -__int128_t { KEYWORD_RETURN(INT); } // GCC +__int128 { KEYWORD_RETURN(INT128); } // GCC +int128 { KEYWORD_RETURN(INT128); } // GCC __label__ { KEYWORD_RETURN(LABEL); } // GCC long { KEYWORD_RETURN(LONG); } @@ -285,5 +291,4 @@ __typeof { KEYWORD_RETURN(TYPEOF); } // GCC __typeof__ { KEYWORD_RETURN(TYPEOF); } // GCC -__uint128_t { KEYWORD_RETURN(INT); } // GCC union { KEYWORD_RETURN(UNION); } unsigned { KEYWORD_RETURN(UNSIGNED); } Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/parser.yy (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:07:12 2017 -// Update Count : 2815 +// Last Modified On : Wed Oct 25 12:28:54 2017 +// Update Count : 2893 // @@ -43,5 +43,5 @@ #define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time #define YYDEBUG 1 // get the pretty debugging code to compile -#define YYERROR_VERBOSE +#define YYERROR_VERBOSE // more information in syntax errors #undef __GNUC_MINOR__ @@ -117,25 +117,22 @@ bool forall = false; // aggregate have one or more forall qualifiers ? -# define YYLLOC_DEFAULT(Cur, Rhs, N) \ -do \ - if (N) { \ - (Cur).first_line = YYRHSLOC(Rhs, 1).first_line; \ - (Cur).first_column = YYRHSLOC(Rhs, 1).first_column; \ - (Cur).last_line = YYRHSLOC(Rhs, N).last_line; \ - (Cur).last_column = YYRHSLOC(Rhs, N).last_column; \ - (Cur).filename = YYRHSLOC(Rhs, 1).filename; \ - } else { \ - (Cur).first_line = (Cur).last_line = \ - YYRHSLOC(Rhs, 0).last_line; \ - (Cur).first_column = (Cur).last_column = \ - YYRHSLOC(Rhs, 0).last_column; \ - (Cur).filename = YYRHSLOC(Rhs, 0).filename; \ - } \ -while (0) +// https://www.gnu.org/software/bison/manual/bison.html#Location-Type +#define YYLLOC_DEFAULT(Cur, Rhs, N) \ +if ( N ) { \ + (Cur).first_line = YYRHSLOC( Rhs, 1 ).first_line; \ + (Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column; \ + (Cur).last_line = YYRHSLOC( Rhs, N ).last_line; \ + (Cur).last_column = YYRHSLOC( Rhs, N ).last_column; \ + (Cur).filename = YYRHSLOC( Rhs, 1 ).filename; \ +} else { \ + (Cur).first_line = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line; \ + (Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column; \ + (Cur).filename = YYRHSLOC( Rhs, 0 ).filename; \ +} %} %define parse.error verbose -// Types declaration +// Types declaration for productions %union { @@ -173,4 +170,5 @@ %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 +%token INT128 FLOAT80 FLOAT128 // GCC %token ZERO_T ONE_T // CFA %token VALIST // GCC @@ -182,5 +180,5 @@ %token ATTRIBUTE EXTENSION // GCC %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN -%token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA +%token CHOOSE DISABLE ENABLE FALLTHRU FALLTHROUGH TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA %token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1) %token ALIGNAS ALIGNOF GENERIC STATICASSERT // C11 @@ -252,4 +250,5 @@ %type exception_statement handler_clause finally_clause %type handler_key +%type mutex_statement %type when_clause when_clause_opt waitfor timeout %type waitfor_statement @@ -363,5 +362,5 @@ %precedence ELSE // token precedence for start of else clause in IF/WAITFOR statement -%locations +%locations // support location tracking for error messages %start translation_unit // parse-tree root @@ -458,14 +457,8 @@ | '(' compound_statement ')' // GCC, lambda expression { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); } - | primary_expression '{' argument_expression_list '}' // CFA, constructor call - { - Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? - $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); - } | type_name '.' no_attr_identifier // CFA, nested type - { $$ = nullptr; } // FIX ME + { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME | type_name '.' '[' push field_list pop ']' // CFA, nested type / tuple field selector - { $$ = nullptr; } // FIX ME + { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME ; @@ -478,4 +471,10 @@ // equivalent to the old x[i,j]. { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); } + | postfix_expression '{' argument_expression_list '}' // CFA, constructor call + { + Token fn; + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); + } | postfix_expression '(' argument_expression_list ')' { $$ = new ExpressionNode( build_func( $1, $3 ) ); } @@ -809,4 +808,5 @@ | jump_statement | with_statement + | mutex_statement | waitfor_statement | exception_statement @@ -974,8 +974,13 @@ ; +fall_through_name: // CFA + FALLTHRU + | FALLTHROUGH + ; + fall_through: // CFA - FALLTHRU + fall_through_name { $$ = nullptr; } - | FALLTHRU ';' + | fall_through_name ';' { $$ = nullptr; } ; @@ -1033,4 +1038,10 @@ ; +// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex". +mutex_statement: + MUTEX '(' argument_expression_list ')' statement + { $$ = nullptr; } // FIX ME + ; + when_clause: WHEN '(' comma_expression ')' @@ -1551,6 +1562,4 @@ | VOLATILE { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); } - | MUTEX - { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); } | ATOMIC { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); } @@ -1606,28 +1615,34 @@ basic_type_name: - CHAR + VOID + { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } + | BOOL // C99 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } + | CHAR { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); } + | INT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } + | INT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); } + | FLOAT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } + | FLOAT80 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); } + | FLOAT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); } | DOUBLE { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } - | FLOAT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } - | INT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } - | LONG - { $$ = DeclarationNode::newLength( DeclarationNode::Long ); } - | SHORT - { $$ = DeclarationNode::newLength( DeclarationNode::Short ); } + | COMPLEX // C99 + { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } + | IMAGINARY // C99 + { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } | SIGNED { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } | UNSIGNED { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } - | VOID - { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } - | BOOL // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - | COMPLEX // C99 - { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } - | IMAGINARY // C99 - { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } + | SHORT + { $$ = DeclarationNode::newLength( DeclarationNode::Short ); } + | LONG + { $$ = DeclarationNode::newLength( DeclarationNode::Long ); } | ZERO_T { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); } @@ -2476,4 +2491,6 @@ | TYPEDEFname | TYPEGENname + | FALLTHROUGH + { $$ = Token{ new string( "fallthrough" ), { nullptr, -1 } }; } | CONST { $$ = Token{ new string( "__const__" ), { nullptr, -1 } }; } @@ -2699,4 +2716,6 @@ paren_identifier attribute_list_opt { $$ = $1->addQualifiers( $2 ); } + | '&' MUTEX paren_identifier attribute_list_opt + { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); } | identifier_parameter_ptr | identifier_parameter_array attribute_list_opt @@ -2739,4 +2758,5 @@ // // typedef int foo; +// forall( otype T ) struct foo; // int f( int foo ); // redefine typedef name in new scope // @@ -2746,4 +2766,6 @@ typedef attribute_list_opt { $$ = $1->addQualifiers( $2 ); } + | '&' MUTEX typedef attribute_list_opt + { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); } | type_parameter_ptr | type_parameter_array attribute_list_opt @@ -2892,4 +2914,6 @@ abstract_parameter_declarator: abstract_parameter_ptr + | '&' MUTEX attribute_list_opt + { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); } | abstract_parameter_array attribute_list_opt { $$ = $1->addQualifiers( $2 ); } Index: src/Parser/parserutility.cc =================================================================== --- src/Parser/parserutility.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/Parser/parserutility.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -29,4 +29,5 @@ Expression *notZeroExpr( Expression *orig ) { + if( !orig ) return nullptr; UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) ); comparison->get_args().push_back( orig ); Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/AdjustExprType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -14,4 +14,5 @@ // +#include "Common/PassVisitor.h" #include "SymTab/Indexer.h" // for Indexer #include "SynTree/Declaration.h" // for TypeDecl, TypeDecl::Kind::Ftype @@ -21,25 +22,27 @@ namespace ResolvExpr { - class AdjustExprType : public Mutator { - typedef Mutator Parent; - using Parent::mutate; + class AdjustExprType : public WithShortCircuiting { public: AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer ); + void premutate( VoidType * ) { visit_children = false; } + void premutate( BasicType * ) { visit_children = false; } + void premutate( PointerType * ) { visit_children = false; } + void premutate( ArrayType * ) { visit_children = false; } + void premutate( FunctionType * ) { visit_children = false; } + void premutate( StructInstType * ) { visit_children = false; } + void premutate( UnionInstType * ) { visit_children = false; } + void premutate( EnumInstType * ) { visit_children = false; } + void premutate( TraitInstType * ) { visit_children = false; } + void premutate( TypeInstType * ) { visit_children = false; } + void premutate( TupleType * ) { visit_children = false; } + void premutate( VarArgsType * ) { visit_children = false; } + void premutate( ZeroType * ) { visit_children = false; } + void premutate( OneType * ) { visit_children = false; } + + Type * postmutate( ArrayType *arrayType ); + Type * postmutate( FunctionType *functionType ); + Type * postmutate( TypeInstType *aggregateUseType ); + private: - virtual Type* mutate( VoidType *voidType ); - virtual Type* mutate( BasicType *basicType ); - virtual Type* mutate( PointerType *pointerType ); - virtual Type* mutate( ArrayType *arrayType ); - virtual Type* mutate( FunctionType *functionType ); - virtual Type* mutate( StructInstType *aggregateUseType ); - virtual Type* mutate( UnionInstType *aggregateUseType ); - virtual Type* mutate( EnumInstType *aggregateUseType ); - virtual Type* mutate( TraitInstType *aggregateUseType ); - virtual Type* mutate( TypeInstType *aggregateUseType ); - virtual Type* mutate( TupleType *tupleType ); - virtual Type* mutate( VarArgsType *varArgsType ); - virtual Type* mutate( ZeroType *zeroType ); - virtual Type* mutate( OneType *oneType ); - const TypeEnvironment &env; const SymTab::Indexer &indexer; @@ -47,5 +50,5 @@ void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { - AdjustExprType adjuster( env, indexer ); + PassVisitor adjuster( env, indexer ); Type *newType = type->acceptMutator( adjuster ); type = newType; @@ -56,45 +59,16 @@ } - Type *AdjustExprType::mutate( VoidType *voidType ) { - return voidType; - } - - Type *AdjustExprType::mutate( BasicType *basicType ) { - return basicType; - } - - Type *AdjustExprType::mutate( PointerType *pointerType ) { - return pointerType; - } - - Type *AdjustExprType::mutate( ArrayType *arrayType ) { - // need to recursively mutate the base type in order for multi-dimensional arrays to work. - PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ) ); + Type * AdjustExprType::postmutate( ArrayType * arrayType ) { + PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base ); + arrayType->base = nullptr; delete arrayType; return pointerType; } - Type *AdjustExprType::mutate( FunctionType *functionType ) { - PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType ); - return pointerType; + Type * AdjustExprType::postmutate( FunctionType * functionType ) { + return new PointerType( Type::Qualifiers(), functionType ); } - Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) { - return aggregateUseType; - } - - Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) { - return aggregateUseType; - } - - Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) { - return aggregateUseType; - } - - Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) { - return aggregateUseType; - } - - Type *AdjustExprType::mutate( TypeInstType *typeInst ) { + Type * AdjustExprType::postmutate( TypeInstType * typeInst ) { EqvClass eqvClass; if ( env.lookup( typeInst->get_name(), eqvClass ) ) { @@ -113,20 +87,4 @@ return typeInst; } - - Type *AdjustExprType::mutate( TupleType *tupleType ) { - return tupleType; - } - - Type *AdjustExprType::mutate( VarArgsType *varArgsType ) { - return varArgsType; - } - - Type *AdjustExprType::mutate( ZeroType *zeroType ) { - return zeroType; - } - - Type *AdjustExprType::mutate( OneType *oneType ) { - return oneType; - } } // namespace ResolvExpr Index: src/ResolvExpr/Alternative.cc =================================================================== --- src/ResolvExpr/Alternative.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/Alternative.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -66,17 +66,17 @@ } - void Alternative::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "Cost " << cost << ": "; + void Alternative::print( std::ostream &os, Indenter indent ) const { + os << "Cost " << cost << ": "; if ( expr ) { - expr->print( os, indent ); - os << "(types:" << std::endl; - os << std::string( indent+4, ' ' ); - expr->get_result()->print( os, indent + 4 ); - os << std::endl << ")" << std::endl; + expr->print( os, indent+1 ); + os << std::endl << indent << "(types:" << std::endl; + os << indent+1; + expr->result->print( os, indent+1 ); + os << std::endl << indent << ")" << std::endl; } else { os << "Null expression!" << std::endl; } // if - os << std::string( indent, ' ' ) << "Environment: "; - env.print( os, indent+2 ); + os << indent << "Environment: "; + env.print( os, indent+1 ); os << std::endl; } Index: src/ResolvExpr/Alternative.h =================================================================== --- src/ResolvExpr/Alternative.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/Alternative.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -39,5 +39,5 @@ ~Alternative(); - void print( std::ostream &os, int indent = 0 ) const; + void print( std::ostream &os, Indenter indent = {} ) const; Cost cost; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/AlternativeFinder.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -76,5 +76,6 @@ namespace { - void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) { + void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) { + Indenter indent = { Indenter::tabsize, indentAmt }; for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) { i->print( os, indent ); @@ -122,4 +123,8 @@ ) mapPlace->second.isAmbiguous = true; + } else { + PRINT( + std::cerr << "cost " << candidate->cost << " loses to " << mapPlace->second.candidate->cost << std::endl; + ) } } else { @@ -127,8 +132,4 @@ } } - - PRINT( - std::cerr << "there are " << selected.size() << " alternatives before elimination" << std::endl; - ) // accept the alternatives that were unambiguous @@ -145,12 +146,12 @@ expr->get_result()->accept( global_renamer ); } - - void referenceToRvalueConversion( Expression *& expr ) { - if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) { - // cast away reference from expr - expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() ); - } - } } // namespace + + void referenceToRvalueConversion( Expression *& expr ) { + if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) { + // cast away reference from expr + expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() ); + } + } template< typename InputIterator, typename OutputIterator > @@ -175,15 +176,11 @@ } - void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) { + void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) { expr->accept( *this ); - if ( alternatives.empty() ) { + if ( failFast && alternatives.empty() ) { throw SemanticError( "No reasonable alternatives for expression ", expr ); } - for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) { - if ( adjust ) { - adjustExprType( i->expr->get_result(), i->env, indexer ); - } - } if ( prune ) { + auto oldsize = alternatives.size(); PRINT( std::cerr << "alternatives before prune:" << std::endl; @@ -192,18 +189,27 @@ AltList::iterator oldBegin = alternatives.begin(); pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) ); - if ( alternatives.begin() == oldBegin ) { + if ( failFast && alternatives.begin() == oldBegin ) { std::ostringstream stream; AltList winners; findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) ); - stream << "Cannot choose between " << winners.size() << " alternatives for expression "; + stream << "Cannot choose between " << winners.size() << " alternatives for expression\n"; expr->print( stream ); - stream << "Alternatives are:"; - printAlts( winners, stream, 8 ); + stream << "Alternatives are:\n"; + printAlts( winners, stream, 1 ); throw SemanticError( stream.str() ); } alternatives.erase( oldBegin, alternatives.end() ); + PRINT( + std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl; + ) PRINT( std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl; ) + } + // adjust types after pruning so that types substituted by pruneAlternatives are correctly adjusted + for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) { + if ( adjust ) { + adjustExprType( i->expr->get_result(), i->env, indexer ); + } } @@ -215,6 +221,14 @@ } - void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) { - find( expr, true, prune ); + void AlternativeFinder::findWithAdjustment( Expression *expr ) { + find( expr, true ); + } + + void AlternativeFinder::findWithoutPrune( Expression * expr ) { + find( expr, true, false ); + } + + void AlternativeFinder::maybeFind( Expression * expr ) { + find( expr, true, true, false ); } @@ -299,5 +313,5 @@ Cost convCost = conversionCost( actualType, formalType, indexer, env ); PRINT( - std::cerr << std::endl << "cost is" << convCost << std::endl; + std::cerr << std::endl << "cost is " << convCost << std::endl; ) if ( convCost == Cost::infinity ) { @@ -305,4 +319,7 @@ } convCost.incPoly( polyCost( formalType, env, indexer ) + polyCost( actualType, env, indexer ) ); + PRINT( + std::cerr << "cost with polycost is " << convCost << std::endl; + ) return convCost; } @@ -310,9 +327,8 @@ Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) { Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env ); - // if ( convCost != Cost::zero ) { - - // xxx - temporary -- ignore poly cost, since this causes some polymorphic functions to be cast, which causes the specialize - // pass to try to specialize them, which currently does not work. Once that is fixed, remove the next 3 lines and uncomment the - // previous line. + + // if there is a non-zero conversion cost, ignoring poly cost, then the expression requires conversion. + // ignore poly cost for now, since this requires resolution of the cast to infer parameters and this + // does not currently work for the reason stated below. Cost tmpCost = convCost; tmpCost.incPoly( -tmpCost.get_polyCost() ); @@ -357,4 +373,5 @@ if ( function->get_isVarArgs() ) { convCost.incUnsafe(); + PRINT( std::cerr << "end of formals with varargs function: inc unsafe: " << convCost << std::endl; ; ) // convert reference-typed expressions to value-typed expressions referenceToRvalueConversion( *actualExpr ); @@ -365,13 +382,4 @@ } Type * formalType = (*formal)->get_type(); - PRINT( - std::cerr << std::endl << "converting "; - actualType->print( std::cerr, 8 ); - std::cerr << std::endl << " to "; - formalType->print( std::cerr, 8 ); - std::cerr << std::endl << "environment is: "; - alt.env.print( std::cerr, 8 ); - std::cerr << std::endl; - ) convCost += computeExpressionConversionCost( *actualExpr, formalType, indexer, alt.env ); ++formal; // can't be in for-loop update because of the continue @@ -481,5 +489,5 @@ Alternative newerAlt( newAlt ); newerAlt.env = newEnv; - assert( (*candidate)->get_uniqueId() ); + assertf( (*candidate)->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( *candidate ).c_str() ); DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ); @@ -507,7 +515,6 @@ std::cerr << std::endl; ) - ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr ); // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter). - InferredParams * inferParameters = &appExpr->get_inferParams(); + InferredParams * inferParameters = &newerAlt.expr->get_inferParams(); for ( UniqueId id : cur->second.idChain ) { inferParameters = (*inferParameters)[ id ].inferParams.get(); @@ -786,21 +793,21 @@ return ! results.empty(); - } + } template - void AlternativeFinder::makeFunctionAlternatives( const Alternative& func, - FunctionType* funcType, const std::vector< AlternativeFinder >& args, + void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, + FunctionType *funcType, const std::vector< AlternativeFinder > &args, OutputIterator out ) { OpenVarSet funcOpenVars; AssertionSet funcNeed, funcHave; - TypeEnvironment funcEnv; + TypeEnvironment funcEnv( func.env ); makeUnifiableVars( funcType, funcOpenVars, funcNeed ); // add all type variables as open variables now so that those not used in the parameter // list are still considered open. funcEnv.add( funcType->get_forall() ); - + if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) { // attempt to narrow based on expected target type - Type* returnType = funcType->get_returnVals().front()->get_type(); + Type * returnType = funcType->get_returnVals().front()->get_type(); if ( ! unify( returnType, targetType, funcEnv, funcNeed, funcHave, funcOpenVars, indexer ) ) { @@ -905,14 +912,11 @@ // find function operators + static NameExpr *opExpr = new NameExpr( "?()" ); AlternativeFinder funcOpFinder( indexer, env ); - NameExpr *opExpr = new NameExpr( "?()" ); - try { - funcOpFinder.findWithAdjustment( opExpr ); - } catch( SemanticError &e ) { - // it's ok if there aren't any defined function ops - } + // it's ok if there aren't any defined function ops + funcOpFinder.maybeFind( opExpr); PRINT( std::cerr << "known function ops:" << std::endl; - printAlts( funcOpFinder.alternatives, std::cerr, 8 ); + printAlts( funcOpFinder.alternatives, std::cerr, 1 ); ) @@ -1028,5 +1032,5 @@ bool isLvalue( Expression *expr ) { // xxx - recurse into tuples? - return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) ); + return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) ); } @@ -1103,9 +1107,5 @@ thisCost.incSafe( discardedValues ); Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ); - // xxx - this doesn't work at the moment, since inferParameters requires an ApplicationExpr as the alternative. - // Once this works, it should be possible to infer parameters on a cast expression and specialize any function. - - // inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) ); - candidates.emplace_back( std::move( newAlt ) ); + inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) ); } // if } // for @@ -1123,6 +1123,5 @@ AlternativeFinder finder( indexer, env ); // don't prune here, since it's guaranteed all alternatives will have the same type - // (giving the alternatives different types is half of the point of ConstructorExpr nodes) - finder.findWithAdjustment( castExpr->get_arg(), false ); + finder.findWithoutPrune( castExpr->get_arg() ); for ( Alternative & alt : finder.alternatives ) { alternatives.push_back( Alternative( @@ -1163,5 +1162,5 @@ PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; ) for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) { - VariableExpr newExpr( *i, nameExpr->get_argName() ); + VariableExpr newExpr( *i ); alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) ); PRINT( @@ -1398,5 +1397,4 @@ findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) ); std::list< AltList > possibilities; - // TODO re-write to use iterative method combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) ); for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) { @@ -1422,5 +1420,5 @@ // don't prune here, since it's guaranteed all alternatives will have the same type // (giving the alternatives different types is half of the point of ConstructorExpr nodes) - finder.findWithAdjustment( ctorExpr->get_callExpr(), false ); + finder.findWithoutPrune( ctorExpr->get_callExpr() ); for ( Alternative & alt : finder.alternatives ) { alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) ); @@ -1459,5 +1457,5 @@ // O(N^2) checks of d-types with e-types for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { - Type * toType = resolveTypeof( initAlt.type, indexer ); + Type * toType = resolveTypeof( initAlt.type->clone(), indexer ); SymTab::validateType( toType, &indexer ); adjustExprType( toType, env, indexer ); @@ -1488,5 +1486,6 @@ // count one safe conversion for each value that is thrown away thisCost.incSafe( discardedValues ); - candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) ); + Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ); + inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) ); } } Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/AlternativeFinder.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -61,7 +61,11 @@ } - void find( Expression *expr, bool adjust = false, bool prune = true ); + void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true ); /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types - void findWithAdjustment( Expression *expr, bool prune = true ); + void findWithAdjustment( Expression *expr ); + /// Calls find with the adjust flag set and prune flag unset; pruning ensures there is at most one alternative per result type + void findWithoutPrune( Expression *expr ); + /// Calls find with the adjust and prune flags set, failFast flags unset; fail fast ensures that there is at least one resulting alternative + void maybeFind( Expression *expr ); AltList &get_alternatives() { return alternatives; } @@ -77,4 +81,9 @@ const SymTab::Indexer &get_indexer() const { return indexer; } const TypeEnvironment &get_environ() const { return env; } + + /// Runs a new alternative finder on each element in [begin, end) + /// and writes each alternative finder to out. + template< typename InputIterator, typename OutputIterator > + void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); private: virtual void visit( ApplicationExpr *applicationExpr ); @@ -108,8 +117,4 @@ virtual void visit( StmtExpr *stmtExpr ); virtual void visit( UntypedInitExpr *initExpr ); - /// Runs a new alternative finder on each element in [begin, end) - /// and writes each alternative finder to out. - template< typename InputIterator, typename OutputIterator > - void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); /// Adds alternatives for anonymous members @@ -134,4 +139,5 @@ Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ); + void referenceToRvalueConversion( Expression *& expr ); template< typename InputIterator, typename OutputIterator > Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/CastCost.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -24,4 +24,9 @@ #include "typeops.h" // for typesCompatibleIgnoreQualifiers +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif namespace ResolvExpr { @@ -52,9 +57,21 @@ } // if } // if + + PRINT( + std::cerr << "castCost ::: src is "; + src->print( std::cerr ); + std::cerr << std::endl << "dest is "; + dest->print( std::cerr ); + std::cerr << std::endl << "env is" << std::endl; + env.print( std::cerr, 8 ); + ) + if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) { + PRINT( std::cerr << "compatible!" << std::endl; ) return Cost::zero; } else if ( dynamic_cast< VoidType* >( dest ) ) { return Cost::safe; } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { + PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) { return ptrsCastable( t1, t2, env, indexer ); Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/CommonType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sun May 17 06:59:27 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 16:24:31 2017 -// Update Count : 7 +// Last Modified On : Mon Sep 25 15:18:17 2017 +// Update Count : 9 // @@ -61,29 +61,20 @@ }; - Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) { - Type * result = nullptr, * common = nullptr; + Type * handleReference( Type * t1, Type * t2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) { + Type * common = nullptr; AssertionSet have, need; OpenVarSet newOpen( openVars ); // need unify to bind type variables - if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) { - // std::cerr << "unify success" << std::endl; - if ( widenSecond ) { - // std::cerr << "widen second" << std::endl; - if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) { - result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone(); - result->get_qualifiers() |= other->get_qualifiers(); - } - } else if ( widenFirst ) { - // std::cerr << "widen first" << std::endl; - if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) { - result = common; - result->get_qualifiers() |= refType->get_qualifiers(); - } - } - } else { - // std::cerr << "exact unify failed: " << refType << " " << other << std::endl; - } - // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl; - return result; + if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) { + // std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl; + if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) { + // std::cerr << "widen okay" << std::endl; + common->get_qualifiers() |= t1->get_qualifiers(); + common->get_qualifiers() |= t2->get_qualifiers(); + return common; + } + } + // std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl; + return nullptr; } @@ -99,8 +90,17 @@ // special case where one type has a reference depth of 1 larger than the other - if ( diff > 0 ) { - return handleReference( strict_dynamic_cast( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars ); - } else if ( diff < 0 ) { - return handleReference( strict_dynamic_cast( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars ); + if ( diff > 0 || diff < 0 ) { + Type * result = nullptr; + if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) { + // formal is reference, so result should be reference + result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars ); + if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result ); + } else { + // formal is value, so result should be value + ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 ); + result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars ); + } + // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl; + return result; } // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor. @@ -150,26 +150,28 @@ static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = { -/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary */ - /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, - /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, - /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, - /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, - /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary } +/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary SignedInt128 UnsignedInt128 */ + /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Float, BasicType::Float, }, + /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Double, BasicType::Double, }, + /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDouble, BasicType::LongDouble, }, + /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::FloatComplex, }, + /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, }, + /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, + /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::FloatImaginary, BasicType::FloatImaginary, }, + /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::DoubleImaginary, BasicType::DoubleImaginary, }, + /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }, + /* SignedInt128 */ { BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedInt128 */ { BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::UnsignedInt128, BasicType::UnsignedInt128, }, }; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/ConversionCost.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:06:19 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Mar 2 17:35:46 2016 -// Update Count : 6 +// Last Modified On : Mon Sep 25 15:43:34 2017 +// Update Count : 10 // @@ -28,10 +28,10 @@ namespace ResolvExpr { - const Cost Cost::zero = Cost( 0, 0, 0, 0 ); - const Cost Cost::infinity = Cost( -1, -1, -1, -1 ); - const Cost Cost::unsafe = Cost( 1, 0, 0, 0 ); - const Cost Cost::poly = Cost( 0, 1, 0, 0 ); - const Cost Cost::safe = Cost( 0, 0, 1, 0 ); - const Cost Cost::reference = Cost( 0, 0, 0, 1 ); + const Cost Cost::zero = Cost( 0, 0, 0, 0 ); + const Cost Cost::infinity = Cost( -1, -1, -1, -1 ); + const Cost Cost::unsafe = Cost( 1, 0, 0, 0 ); + const Cost Cost::poly = Cost( 0, 1, 0, 0 ); + const Cost Cost::safe = Cost( 0, 0, 1, 0 ); + const Cost Cost::reference = Cost( 0, 0, 0, 1 ); #if 0 @@ -113,7 +113,7 @@ int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer ); PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) - if ( assignResult < 0 ) { + if ( assignResult > 0 ) { return Cost::safe; - } else if ( assignResult > 0 ) { + } else if ( assignResult < 0 ) { return Cost::unsafe; } // if @@ -219,28 +219,31 @@ */ - static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = - { - /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag */ - /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10, 11, 12, 11, 12, 13, -1, -1, -1 }, - /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 10, 11, 12, -1, -1, -1 }, - /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 10, 11, 12, -1, -1, -1 }, - /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 9, 10, 11, -1, -1, -1 }, - /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 8, 9, 10, -1, -1, -1 }, - /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 7, 8, 9, -1, -1, -1 }, - /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 5, 6, 7, 6, 7, 8, -1, -1, -1 }, - /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 4, 5, 6, 5, 6, 7, -1, -1, -1 }, - /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, -1, -1, -1 }, - /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 4, 5, 6, -1, -1, -1 }, - /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 3, 4, 5, -1, -1, -1 }, - /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 2, 3, 4, -1, -1, -1 }, - /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1 }, - /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1 }, - /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1 }, - /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1 }, - /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1 }, - /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1 }, - /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2 }, - /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1 }, - /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0 } + static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = { + /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag I128, U128 */ + /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 12, 13, 14, 12, 13, 14, -1, -1, -1, 10, 11, }, + /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, + /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, + /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 10, 11, 12, -1, -1, -1, 8, 9, }, + /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 9, 10, 11, 9, 10, 11, -1, -1, -1, 7, 8, }, + /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 8, 9, 10, 8, 9, 10, -1, -1, -1, 6, 7, }, + /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 7, 8, 9, 7, 8, 9, -1, -1, -1, 5, 6, }, + /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, + /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, + /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 5, 6, 7, 5, 6, 7, -1, -1, -1, 3, 4, }, + /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 4, 5, 6, 4, 5, 6, -1, -1, -1, 2, 3, }, + /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 4, 5, 3, 4, 5, -1, -1, -1, 1, 2, }, + + /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1, -1, -1, }, + /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1, -1, -1, }, + /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1, -1, -1, }, + /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1, -1, -1, }, + /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1, -1, -1, }, + /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, }, + /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2, -1, -1, }, + /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1, -1, -1, }, + /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0, -1, -1, }, + + /* I128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 4, 3, 4, 5, -1, -1, -1, 0, 1, }, + /* U128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 2, 3, 4, -1, -1, -1, -1, 0, }, }; @@ -266,5 +269,5 @@ } - void ConversionCost::visit(PointerType *pointerType) { + void ConversionCost::visit( PointerType * pointerType ) { if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { PRINT( std::cerr << pointerType << " ===> " << destAsPtr; ) @@ -281,21 +284,21 @@ } } else { // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? - int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env ); + int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env ); PRINT( std::cerr << " :: " << assignResult << std::endl; ) - if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) { + if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) { cost = Cost::safe; - } else if ( assignResult > 0 ) { + } else if ( assignResult < 0 ) { cost = Cost::unsafe; } // if // assignResult == 0 means Cost::Infinity } // if - } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) { + } else if ( dynamic_cast< ZeroType * >( dest ) ) { cost = Cost::unsafe; } // if } - void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {} - - void ConversionCost::visit(ReferenceType *refType) { + void ConversionCost::visit( ArrayType * ) {} + + void ConversionCost::visit( ReferenceType * refType ) { // Note: dest can never be a reference, since it would have been caught in an earlier check assert( ! dynamic_cast< ReferenceType * >( dest ) ); @@ -303,8 +306,8 @@ // recursively compute conversion cost from T1 to T2. // cv can be safely dropped because of 'implicit dereference' behavior. - refType->get_base()->accept( *this ); - if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) { + refType->base->accept( *this ); + if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) { cost.incReference(); // prefer exact qualifiers - } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) { + } else if ( refType->base->get_qualifiers() < dest->get_qualifiers() ) { cost.incSafe(); // then gaining qualifiers } else { @@ -314,23 +317,23 @@ } - void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {} - - void ConversionCost::visit(StructInstType *inst) { + void ConversionCost::visit( FunctionType * ) {} + + void ConversionCost::visit( StructInstType * inst ) { if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) { - if ( inst->get_name() == destAsInst->get_name() ) { - cost = Cost::zero; - } // if - } // if - } - - void ConversionCost::visit(UnionInstType *inst) { - if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) { - if ( inst->get_name() == destAsInst->get_name() ) { - cost = Cost::zero; - } // if - } // if - } - - void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) { + if ( inst->name == destAsInst->name ) { + cost = Cost::zero; + } // if + } // if + } + + void ConversionCost::visit( UnionInstType * inst ) { + if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) { + if ( inst->name == destAsInst->name ) { + cost = Cost::zero; + } // if + } // if + } + + void ConversionCost::visit( EnumInstType * ) { static Type::Qualifiers q; static BasicType integer( q, BasicType::SignedInt ); @@ -341,8 +344,7 @@ } - void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) { - } - - void ConversionCost::visit(TypeInstType *inst) { + void ConversionCost::visit( TraitInstType * ) {} + + void ConversionCost::visit( TypeInstType *inst ) { EqvClass eqvClass; NamedTypeDecl *namedType; @@ -363,9 +365,9 @@ } - void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) { + void ConversionCost::visit( TupleType * tupleType ) { Cost c = Cost::zero; - if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) { - std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin(); - std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin(); + if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) { + std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin(); + std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin(); while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) { Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env ); @@ -383,5 +385,5 @@ } - void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) { + void ConversionCost::visit( VarArgsType * ) { if ( dynamic_cast< VarArgsType* >( dest ) ) { cost = Cost::zero; @@ -389,6 +391,6 @@ } - void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) { - if ( dynamic_cast< ZeroType* >( dest ) ) { + void ConversionCost::visit( ZeroType * ) { + if ( dynamic_cast< ZeroType * >( dest ) ) { cost = Cost::zero; } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) { @@ -406,6 +408,6 @@ } - void ConversionCost::visit( __attribute((unused)) OneType *oneType) { - if ( dynamic_cast< OneType* >( dest ) ) { + void ConversionCost::visit( OneType * ) { + if ( dynamic_cast< OneType * >( dest ) ) { cost = Cost::zero; } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) { Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/CurrentObject.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -260,4 +260,5 @@ AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) { + PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; ) init(); } Index: src/ResolvExpr/PolyCost.cc =================================================================== --- src/ResolvExpr/PolyCost.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/PolyCost.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// PolyCost.cc -- +// PolyCost.cc -- // // Author : Richard C. Bilson @@ -31,5 +31,5 @@ }; - int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { + int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) { PolyCost coster( env, indexer ); type->accept( coster ); @@ -37,16 +37,18 @@ } - PolyCost::PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer ) : result( 0 ), env( env ), indexer( indexer ) { + PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), env( env ), indexer( indexer ) { } - void PolyCost::visit(TypeInstType *typeInst) { + void PolyCost::visit(TypeInstType * typeInst) { EqvClass eqvClass; - if ( env.lookup( typeInst->get_name(), eqvClass ) ) { + if ( env.lookup( typeInst->name, eqvClass ) ) { if ( eqvClass.type ) { - if ( TypeInstType *otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) { - if ( indexer.lookupType( otherTypeInst->get_name() ) ) { + if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) { + if ( indexer.lookupType( otherTypeInst->name ) ) { + // bound to opaque type result += 1; } // if } else { + // bound to concrete type result += 1; } // if Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/PtrsAssignable.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -47,4 +47,5 @@ int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env ) { + // std::cerr << "assignable: " << src << " | " << dest << std::endl; if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { EqvClass eqvClass; @@ -54,5 +55,7 @@ } // if if ( dynamic_cast< VoidType* >( dest ) ) { - return 1; + // void * = T * for any T is unsafe + // xxx - this should be safe, but that currently breaks the build + return -1; } else { PtrsAssignable ptrs( dest, env ); @@ -65,8 +68,8 @@ void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) { - if ( dynamic_cast< FunctionType* >( dest ) ) { - result = 0; - } else { - result = -1; + if ( ! dynamic_cast< FunctionType* >( dest ) ) { + // T * = void * is safe for any T that is not a function type. + // xxx - this should be unsafe... + result = 1; } // if } @@ -75,7 +78,5 @@ void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {} void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {} - void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) { - result = -1; - } + void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {} void PtrsAssignable::visit( __attribute__((unused)) StructInstType *inst ) {} @@ -83,8 +84,11 @@ void PtrsAssignable::visit( EnumInstType * ) { - if ( dynamic_cast< EnumInstType* >( dest ) ) { + if ( dynamic_cast< BasicType* >( dest ) ) { + // int * = E *, etc. is safe. This isn't technically correct, as each + // enum has one basic type that it is compatible with, an that type can + // differ from enum to enum. Without replicating GCC's internal logic, + // there is no way to know which type this particular enum is compatible + // with, so punt on this for now. result = 1; - } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) { - result = bt->get_kind() == BasicType::SignedInt; } } @@ -94,7 +98,6 @@ EqvClass eqvClass; if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) { + // T * = S * for any S depends on the type bound to T result = ptrsAssignable( eqvClass.type, dest, env ); - } else { - result = 0; } // if } Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/PtrsCastable.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -50,25 +50,27 @@ }; - int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { - if ( dynamic_cast< FunctionType* >( src ) ) { - return -1; - } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) { - EqvClass eqvClass; - if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) { - if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) { - if ( tyDecl->get_kind() == TypeDecl::Ftype ) { + namespace { + int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { + if ( dynamic_cast< FunctionType* >( src ) ) { + return -1; + } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) { + EqvClass eqvClass; + if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) { + if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) { + if ( tyDecl->get_kind() == TypeDecl::Ftype ) { + return -1; + } // if + } //if + } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) { + if ( eqvClass.data.kind == TypeDecl::Ftype ) { return -1; } // if - } //if - } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) { - if ( eqvClass.data.kind == TypeDecl::Ftype ) { - return -1; } // if - } // if - } //if - return 1; - } - int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { - return -1 * objectCast( src, env, indexer ); // reverse the sense of objectCast + } //if + return 1; + } + int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) { + return -1 * objectCast( src, env, indexer ); // reverse the sense of objectCast + } } @@ -93,34 +95,34 @@ } - void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) { + void PtrsCastable::visit( VoidType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) { + void PtrsCastable::visit( BasicType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) { + void PtrsCastable::visit( PointerType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) { + void PtrsCastable::visit( ArrayType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) { + void PtrsCastable::visit( FunctionType * ) { // result = -1; result = functionCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) { + void PtrsCastable::visit( StructInstType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) { + void PtrsCastable::visit( UnionInstType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) { + void PtrsCastable::visit( EnumInstType * ) { if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; @@ -136,5 +138,5 @@ } - void PtrsCastable::visit( __attribute__((unused)) TraitInstType *inst ) {} + void PtrsCastable::visit( TraitInstType * ) {} void PtrsCastable::visit(TypeInstType *inst) { @@ -143,17 +145,17 @@ } - void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) { + void PtrsCastable::visit( TupleType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) { + void PtrsCastable::visit( VarArgsType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) { + void PtrsCastable::visit( ZeroType * ) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) { + void PtrsCastable::visit( OneType * ) { result = objectCast( dest, env, indexer ); } Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/ResolveTypeof.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -18,4 +18,5 @@ #include // for assert +#include "Common/PassVisitor.h" // for PassVisitor #include "Resolver.h" // for resolveInVoidContext #include "SynTree/Expression.h" // for Expression @@ -41,8 +42,9 @@ } - class ResolveTypeof : public Mutator { + class ResolveTypeof : public WithShortCircuiting { public: ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {} - Type *mutate( TypeofType *typeofType ); + void premutate( TypeofType *typeofType ); + Type * postmutate( TypeofType *typeofType ); private: @@ -50,20 +52,24 @@ }; - Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) { - ResolveTypeof mutator( indexer ); + Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) { + PassVisitor mutator( indexer ); return type->acceptMutator( mutator ); } - Type *ResolveTypeof::mutate( TypeofType *typeofType ) { + void ResolveTypeof::premutate( TypeofType * ) { + visit_children = false; + } + + Type * ResolveTypeof::postmutate( TypeofType *typeofType ) { #if 0 - std::cout << "resolving typeof: "; - typeofType->print( std::cout ); - std::cout << std::endl; + std::cerr << "resolving typeof: "; + typeofType->print( std::cerr ); + std::cerr << std::endl; #endif - if ( typeofType->get_expr() ) { - Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer ); - assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() ); - Type *newType = newExpr->get_result(); - newExpr->set_result( nullptr ); + if ( typeofType->expr ) { + Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer ); + assert( newExpr->result && ! newExpr->result->isVoid() ); + Type * newType = newExpr->result; + newExpr->result = nullptr; delete typeofType; delete newExpr; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/Resolver.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -40,4 +40,5 @@ #include "SynTree/Visitor.h" // for acceptAll, maybeAccept #include "typeops.h" // for extractResultType +#include "Unify.h" // for unify using namespace std; @@ -52,5 +53,5 @@ void previsit( FunctionDecl *functionDecl ); void postvisit( FunctionDecl *functionDecl ); - void previsit( ObjectDecl *functionDecl ); + void previsit( ObjectDecl *objectDecll ); void previsit( TypeDecl *typeDecl ); void previsit( EnumDecl * enumDecl ); @@ -71,4 +72,5 @@ void previsit( ThrowStmt *throwStmt ); void previsit( CatchStmt *catchStmt ); + void previsit( WaitForStmt * stmt ); void previsit( SingleInit *singleInit ); @@ -95,4 +97,9 @@ } + void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) { + PassVisitor resolver( indexer ); + maybeAccept( decl, resolver ); + } + // used in resolveTypeof Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) { @@ -102,40 +109,62 @@ namespace { - void finishExpr( Expression *expr, const TypeEnvironment &env ) { - expr->set_env( new TypeSubstitution ); + void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) { + expr->env = oldenv ? oldenv->clone() : new TypeSubstitution; env.makeSubstitution( *expr->get_env() ); } + + void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) { + if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) { + // cast is to the same type as its argument, so it's unnecessary -- remove it + expr = castExpr->arg; + castExpr->arg = nullptr; + std::swap( expr->env, castExpr->env ); + delete castExpr; + } + } + } } // namespace - Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) { + void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { global_renamer.reset(); TypeEnvironment env; Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); - finishExpr( newExpr, env ); - return newExpr; + finishExpr( newExpr, env, untyped->env ); + delete untyped; + untyped = newExpr; + } + + void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) { + if ( ! untyped ) return; + TypeEnvironment env; + AlternativeFinder finder( indexer, env ); + finder.find( untyped ); + #if 0 + if ( finder.get_alternatives().size() != 1 ) { + std::cerr << "untyped expr is "; + untyped->print( std::cerr ); + std::cerr << std::endl << "alternatives are:"; + for ( const Alternative & alt : finder.get_alternatives() ) { + alt.print( std::cerr ); + } // for + } // if + #endif + assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); + Alternative &choice = finder.get_alternatives().front(); + Expression *newExpr = choice.expr->clone(); + finishExpr( newExpr, choice.env, untyped->env ); + delete untyped; + untyped = newExpr; + } + + void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) { + assert( untyped && type ); + untyped = new CastExpr( untyped, type ); + findSingleExpression( untyped, indexer ); + removeExtraneousCast( untyped, indexer ); } namespace { - Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { - TypeEnvironment env; - AlternativeFinder finder( indexer, env ); - finder.find( untyped ); -#if 0 - if ( finder.get_alternatives().size() != 1 ) { - std::cout << "untyped expr is "; - untyped->print( std::cout ); - std::cout << std::endl << "alternatives are:"; - for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { - i->print( std::cout ); - } // for - } // if -#endif - assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); - Alternative &choice = finder.get_alternatives().front(); - Expression *newExpr = choice.expr->clone(); - finishExpr( newExpr, choice.env ); - return newExpr; - } - bool isIntegralType( Type *type ) { if ( dynamic_cast< EnumInstType * >( type ) ) { @@ -150,5 +179,5 @@ } - Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) { + void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) { TypeEnvironment env; AlternativeFinder finder( indexer, env ); @@ -179,6 +208,7 @@ throw SemanticError( "No interpretations for case control expression", untyped ); } // if - finishExpr( newExpr, *newEnv ); - return newExpr; + finishExpr( newExpr, *newEnv, untyped->env ); + delete untyped; + untyped = newExpr; } @@ -205,8 +235,5 @@ void Resolver::handlePtrType( PtrType * type ) { if ( type->get_dimension() ) { - CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() ); - Expression *newExpr = findSingleExpression( castExpr, indexer ); - delete type->get_dimension(); - type->set_dimension( newExpr ); + findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer ); } } @@ -238,5 +265,4 @@ functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() ); } - void Resolver::postvisit( FunctionDecl *functionDecl ) { @@ -262,19 +288,13 @@ void Resolver::previsit( ExprStmt *exprStmt ) { visit_children = false; - assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" ); - Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer ); - delete exprStmt->get_expr(); - exprStmt->set_expr( newExpr ); + assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" ); + findVoidExpression( exprStmt->expr, indexer ); } void Resolver::previsit( AsmExpr *asmExpr ) { visit_children = false; - Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer ); - delete asmExpr->get_operand(); - asmExpr->set_operand( newExpr ); + findVoidExpression( asmExpr->operand, indexer ); if ( asmExpr->get_inout() ) { - newExpr = findVoidExpression( asmExpr->get_inout(), indexer ); - delete asmExpr->get_inout(); - asmExpr->set_inout( newExpr ); + findVoidExpression( asmExpr->inout, indexer ); } // if } @@ -287,26 +307,18 @@ void Resolver::previsit( IfStmt *ifStmt ) { - Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer ); - delete ifStmt->get_condition(); - ifStmt->set_condition( newExpr ); + findSingleExpression( ifStmt->condition, indexer ); } void Resolver::previsit( WhileStmt *whileStmt ) { - Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer ); - delete whileStmt->get_condition(); - whileStmt->set_condition( newExpr ); + findSingleExpression( whileStmt->condition, indexer ); } void Resolver::previsit( ForStmt *forStmt ) { - if ( forStmt->get_condition() ) { - Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer ); - delete forStmt->get_condition(); - forStmt->set_condition( newExpr ); + if ( forStmt->condition ) { + findSingleExpression( forStmt->condition, indexer ); } // if - if ( forStmt->get_increment() ) { - Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer ); - delete forStmt->get_increment(); - forStmt->set_increment( newExpr ); + if ( forStmt->increment ) { + findVoidExpression( forStmt->increment, indexer ); } // if } @@ -314,10 +326,7 @@ void Resolver::previsit( SwitchStmt *switchStmt ) { GuardValue( currentObject ); - Expression *newExpr; - newExpr = findIntegralExpression( switchStmt->get_condition(), indexer ); - delete switchStmt->get_condition(); - switchStmt->set_condition( newExpr ); - - currentObject = CurrentObject( newExpr->get_result() ); + findIntegralExpression( switchStmt->condition, indexer ); + + currentObject = CurrentObject( switchStmt->condition->result ); } @@ -326,9 +335,10 @@ std::list< InitAlternative > initAlts = currentObject.getOptions(); assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." ); - CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() ); - Expression * newExpr = findSingleExpression( castExpr, indexer ); - castExpr = strict_dynamic_cast< CastExpr * >( newExpr ); - caseStmt->set_condition( castExpr->get_arg() ); - castExpr->set_arg( nullptr ); + // must remove cast from case statement because RangeExpr cannot be cast. + Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() ); + findSingleExpression( newExpr, indexer ); + CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr ); + caseStmt->condition = castExpr->arg; + castExpr->arg = nullptr; delete castExpr; } @@ -339,10 +349,7 @@ // must resolve the argument for a computed goto if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement - if ( Expression * arg = branchStmt->get_computedTarget() ) { - VoidType v = Type::Qualifiers(); // cast to void * for the alternative finder - PointerType pt( Type::Qualifiers(), v.clone() ); - CastExpr * castExpr = new CastExpr( arg, pt.clone() ); - Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression - branchStmt->set_target( newExpr ); + if ( branchStmt->computedTarget ) { + // computed goto argument is void * + findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer ); } // if } // if @@ -351,9 +358,6 @@ void Resolver::previsit( ReturnStmt *returnStmt ) { visit_children = false; - if ( returnStmt->get_expr() ) { - CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() ); - Expression *newExpr = findSingleExpression( castExpr, indexer ); - delete castExpr; - returnStmt->set_expr( newExpr ); + if ( returnStmt->expr ) { + findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer ); } // if } @@ -366,26 +370,201 @@ indexer.lookupStruct( "__cfaehm__base_exception_t" ); assert( exception_decl ); - Expression * wrapped = new CastExpr( - throwStmt->get_expr(), - new PointerType( - noQualifiers, - new StructInstType( - noQualifiers, - exception_decl - ) - ) - ); - Expression * newExpr = findSingleExpression( wrapped, indexer ); - throwStmt->set_expr( newExpr ); + Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) ); + findSingleExpression( throwStmt->expr, exceptType, indexer ); } } void Resolver::previsit( CatchStmt *catchStmt ) { - if ( catchStmt->get_cond() ) { - Expression * wrapped = new CastExpr( - catchStmt->get_cond(), - new BasicType( noQualifiers, BasicType::Bool ) - ); - catchStmt->set_cond( findSingleExpression( wrapped, indexer ) ); + if ( catchStmt->cond ) { + findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer ); + } + } + + template< typename iterator_t > + inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) { + while( it != end && !(*it)->get_type()->get_mutex() ) { + it++; + } + + return it != end; + } + + void Resolver::previsit( WaitForStmt * stmt ) { + visit_children = false; + + // Resolve all clauses first + for( auto& clause : stmt->clauses ) { + + TypeEnvironment env; + AlternativeFinder funcFinder( indexer, env ); + + // Find all alternatives for a function in canonical form + funcFinder.findWithAdjustment( clause.target.function ); + + if ( funcFinder.get_alternatives().empty() ) { + stringstream ss; + ss << "Use of undeclared indentifier '"; + ss << strict_dynamic_cast( clause.target.function )->name; + ss << "' in call to waitfor"; + throw SemanticError( ss.str() ); + } + + // Find all alternatives for all arguments in canonical form + std::list< AlternativeFinder > argAlternatives; + funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) ); + + // List all combinations of arguments + std::list< AltList > possibilities; + combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) ); + + AltList func_candidates; + std::vector< AltList > args_candidates; + + // For every possible function : + // try matching the arguments to the parameters + // not the other way around because we have more arguments than parameters + SemanticError errors; + for ( Alternative & func : funcFinder.get_alternatives() ) { + try { + PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() ); + if( !pointer ) { + throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() ); + } + + FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() ); + if( !function ) { + throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() ); + } + + + { + auto param = function->parameters.begin(); + auto param_end = function->parameters.end(); + + if( !advance_to_mutex( param, param_end ) ) { + throw SemanticError("candidate function not viable: no mutex parameters\n", function); + } + } + + Alternative newFunc( func ); + // Strip reference from function + referenceToRvalueConversion( newFunc.expr ); + + // For all the set of arguments we have try to match it with the parameter of the current function alternative + for ( auto & argsList : possibilities ) { + + try { + // Declare data structures need for resolution + OpenVarSet openVars; + AssertionSet resultNeed, resultHave; + TypeEnvironment resultEnv; + + // Load type variables from arguemnts into one shared space + simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv ); + + // Make sure we don't widen any existing bindings + for ( auto & i : resultEnv ) { + i.allowWidening = false; + } + + // Find any unbound type variables + resultEnv.extractOpenVars( openVars ); + + auto param = function->parameters.begin(); + auto param_end = function->parameters.end(); + + // For every arguments of its set, check if it matches one of the parameter + // The order is important + for( auto & arg : argsList ) { + + // Ignore non-mutex arguments + if( !advance_to_mutex( param, param_end ) ) { + // We ran out of parameters but still have arguments + // this function doesn't match + throw SemanticError("candidate function not viable: too many mutex arguments\n", function); + } + + // Check if the argument matches the parameter type in the current scope + if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) { + // Type doesn't match + stringstream ss; + ss << "candidate function not viable: no known convertion from '"; + arg.expr->get_result()->print( ss ); + ss << "' to '"; + (*param)->get_type()->print( ss ); + ss << "'\n"; + throw SemanticError(ss.str(), function); + } + + param++; + } + + // All arguments match ! + + // Check if parameters are missing + if( advance_to_mutex( param, param_end ) ) { + // We ran out of arguments but still have parameters left + // this function doesn't match + throw SemanticError("candidate function not viable: too few mutex arguments\n", function); + } + + // All parameters match ! + + // Finish the expressions to tie in the proper environments + finishExpr( newFunc.expr, resultEnv ); + for( Alternative & alt : argsList ) { + finishExpr( alt.expr, resultEnv ); + } + + // This is a match store it and save it for later + func_candidates.push_back( newFunc ); + args_candidates.push_back( argsList ); + + } + catch( SemanticError &e ) { + errors.append( e ); + } + } + } + catch( SemanticError &e ) { + errors.append( e ); + } + } + + // Make sure we got the right number of arguments + if( func_candidates.empty() ) { SemanticError top( "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.empty() ) { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; } + if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; } + + + // Swap the results from the alternative with the unresolved values. + // Alternatives will handle deletion on destruction + std::swap( clause.target.function, func_candidates.front().expr ); + for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) { + std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr ); + } + + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + findSingleExpression( clause.condition, this->indexer ); + clause.statement->accept( *visitor ); + } + + + if( stmt->timeout.statement ) { + // Resolve the timeout as an size_t for now + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer ); + findSingleExpression( stmt->timeout.condition, this->indexer ); + stmt->timeout.statement->accept( *visitor ); + } + + if( stmt->orelse.statement ) { + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + findSingleExpression( stmt->orelse.condition, this->indexer ); + stmt->orelse.statement->accept( *visitor ); } } @@ -403,6 +582,6 @@ visit_children = false; // resolve initialization using the possibilities as determined by the currentObject cursor - UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() ); - Expression * newExpr = findSingleExpression( untyped, indexer ); + Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() ); + findSingleExpression( newExpr, indexer ); InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr ); @@ -411,12 +590,14 @@ // discard InitExpr wrapper and retain relevant pieces - newExpr = initExpr->get_expr(); - newExpr->set_env( initExpr->get_env() ); - initExpr->set_expr( nullptr ); - initExpr->set_env( nullptr ); + newExpr = initExpr->expr; + initExpr->expr = nullptr; + std::swap( initExpr->env, newExpr->env ); + std::swap( initExpr->inferParams, newExpr->inferParams ) ; delete initExpr; // get the actual object's type (may not exactly match what comes back from the resolver due to conversions) Type * initContext = currentObject.getCurrentType(); + + removeExtraneousCast( newExpr, indexer ); // check if actual object's type is char[] @@ -426,9 +607,11 @@ if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) { if ( isCharType( pt->get_base() ) ) { - // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; - CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr ); - newExpr = ce->get_arg(); - ce->set_arg( nullptr ); - delete ce; + if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) { + // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; + newExpr = ce->get_arg(); + ce->set_arg( nullptr ); + std::swap( ce->env, newExpr->env ); + delete ce; + } } } @@ -437,5 +620,5 @@ // set initializer expr to resolved express - singleInit->set_value( newExpr ); + singleInit->value = newExpr; // move cursor to next object in preparation for next initializer Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/Resolver.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -29,6 +29,8 @@ /// Checks types and binds syntactic constructs to typed representations void resolve( std::list< Declaration * > translationUnit ); - Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ); - Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ); + void resolveDecl( Declaration *, const SymTab::Indexer &indexer ); + Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer ); + void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ); + void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer ); void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ); void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ); Index: src/ResolvExpr/TypeEnvironment.cc =================================================================== --- src/ResolvExpr/TypeEnvironment.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/TypeEnvironment.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -68,11 +68,11 @@ } - void EqvClass::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "( "; + void EqvClass::print( std::ostream &os, Indenter indent ) const { + os << "( "; std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) ); os << ")"; if ( type ) { os << " -> "; - type->print( os, indent ); + type->print( os, indent+1 ); } // if if ( ! allowWidening ) { @@ -123,13 +123,13 @@ for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) { for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) { -/// std::cout << "adding " << *theVar; +/// std::cerr << "adding " << *theVar; if ( theClass->type ) { -/// std::cout << " bound to "; -/// theClass->type->print( std::cout ); -/// std::cout << std::endl; +/// std::cerr << " bound to "; +/// theClass->type->print( std::cerr ); +/// std::cerr << std::endl; sub.add( *theVar, theClass->type ); } else if ( theVar != theClass->vars.begin() ) { TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype ); -/// std::cout << " bound to variable " << *theClass->vars.begin() << std::endl; +/// std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl; sub.add( *theVar, newTypeInst ); delete newTypeInst; @@ -144,5 +144,5 @@ } - void TypeEnvironment::print( std::ostream &os, int indent ) const { + void TypeEnvironment::print( std::ostream &os, Indenter indent ) const { for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) { i->print( os, indent ); Index: src/ResolvExpr/TypeEnvironment.h =================================================================== --- src/ResolvExpr/TypeEnvironment.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/TypeEnvironment.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -68,5 +68,5 @@ EqvClass &operator=( const EqvClass &other ); ~EqvClass(); - void print( std::ostream &os, int indent = 0 ) const; + void print( std::ostream &os, Indenter indent = {} ) const; }; @@ -80,5 +80,5 @@ void makeSubstitution( TypeSubstitution &result ) const; bool isEmpty() const { return env.empty(); } - void print( std::ostream &os, int indent = 0 ) const; + void print( std::ostream &os, Indenter indent = {} ) const; void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) ); void simpleCombine( const TypeEnvironment &second ); Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/ResolvExpr/Unify.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -17,9 +17,10 @@ #include // for back_insert_iterator, back_inserter #include // for _Rb_tree_const_iterator, _Rb_tree_i... -#include // for unique_ptr, auto_ptr +#include // for unique_ptr #include // for set #include // for string, operator==, operator!=, bas... #include // for pair +#include "Common/PassVisitor.h" // for PassVisitor #include "FindOpenVars.h" // for findOpenVars #include "Parser/LinkageSpec.h" // for C @@ -137,5 +138,4 @@ bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) { switch ( data.kind ) { - case TypeDecl::Any: case TypeDecl::Dtype: // to bind to an object type variable, the type must not be a function type. @@ -169,5 +169,5 @@ Type *common = 0; // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to - std::auto_ptr< Type > newType( curClass.type->clone() ); + std::unique_ptr< Type > newType( curClass.type->clone() ); newType->get_qualifiers() = typeInst->get_qualifiers(); if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) { @@ -458,9 +458,4 @@ if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) { - // not positive this is correct in all cases, but it's needed for typedefs - if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) { - return; - } - if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() && arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) { @@ -537,10 +532,11 @@ /// If this isn't done then argument lists can have wildly different /// size and structure, when they should be compatible. - struct TtypeExpander : public Mutator { - TypeEnvironment & env; - TtypeExpander( TypeEnvironment & env ) : env( env ) {} - Type * mutate( TypeInstType * typeInst ) { + struct TtypeExpander : public WithShortCircuiting { + TypeEnvironment & tenv; + TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {} + void premutate( TypeInstType * ) { visit_children = false; } + Type * postmutate( TypeInstType * typeInst ) { EqvClass eqvClass; - if ( env.lookup( typeInst->get_name(), eqvClass ) ) { + if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) { if ( eqvClass.data.kind == TypeDecl::Ttype ) { // expand ttype parameter into its actual type @@ -560,5 +556,5 @@ dst.clear(); for ( DeclarationWithType * dcl : src ) { - TtypeExpander expander( env ); + PassVisitor expander( env ); dcl->acceptMutator( expander ); std::list< Type * > types; @@ -750,5 +746,5 @@ std::list types1, types2; - TtypeExpander expander( env ); + PassVisitor expander( env ); flat1->acceptMutator( expander ); flat2->acceptMutator( expander ); Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Autogen.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -16,5 +16,4 @@ #include "Autogen.h" -#include // for NULL #include // for count_if #include // for strict_dynamic_cast, assert, assertf @@ -27,8 +26,10 @@ #include "AddVisit.h" // for addVisit #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign +#include "Common/PassVisitor.h" // for PassVisitor #include "Common/ScopedMap.h" // for ScopedMap<>::const_iterator, Scope... #include "Common/utility.h" // for cloneAll, operator+ -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::iterator +#include "InitTweak/GenInit.h" // for fixReturnStatements +#include "ResolvExpr/Resolver.h" // for resolveDecl #include "SymTab/Mangler.h" // for Mangler #include "SynTree/Attribute.h" // For Attribute @@ -42,67 +43,44 @@ namespace SymTab { Type * SizeType = 0; - typedef ScopedMap< std::string, bool > TypeMap; - - /// Data used to generate functions generically. Specifically, the name of the generated function, a function which generates the routine protoype, and a map which contains data to determine whether a function should be generated. + + /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype struct FuncData { typedef FunctionType * (*TypeGen)( Type * ); - FuncData( const std::string & fname, const TypeGen & genType, TypeMap & map ) : fname( fname ), genType( genType ), map( map ) {} + FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {} std::string fname; TypeGen genType; - TypeMap & map; - }; - - class AutogenerateRoutines final : public Visitor { - template< typename Visitor > - friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor ); - template< typename Visitor > - friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor ); - public: - std::list< Declaration * > &get_declsToAdd() { return declsToAdd; } - - typedef Visitor Parent; - using Parent::visit; - + }; + + struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef, public WithGuards, public WithShortCircuiting, public WithIndexer { AutogenerateRoutines(); - virtual void visit( EnumDecl *enumDecl ); - virtual void visit( StructDecl *structDecl ); - virtual void visit( UnionDecl *structDecl ); - virtual void visit( TypeDecl *typeDecl ); - virtual void visit( TraitDecl *ctxDecl ); - virtual void visit( FunctionDecl *functionDecl ); - - virtual void visit( FunctionType *ftype ); - virtual void visit( PointerType *ftype ); - - virtual void visit( CompoundStmt *compoundStmt ); - virtual void visit( SwitchStmt *switchStmt ); + void previsit( EnumDecl * enumDecl ); + void previsit( StructDecl * structDecl ); + void previsit( UnionDecl * structDecl ); + void previsit( TypeDecl * typeDecl ); + void previsit( TraitDecl * traitDecl ); + void previsit( FunctionDecl * functionDecl ); + + void previsit( FunctionType * ftype ); + void previsit( PointerType * ptype ); + + void previsit( CompoundStmt * compoundStmt ); private: - template< typename StmtClass > void visitStatement( StmtClass *stmt ); - - std::list< Declaration * > declsToAdd, declsToAddAfter; - std::set< std::string > structsDone; + + GenPoly::ScopedSet< std::string > structsDone; unsigned int functionNesting = 0; // current level of nested functions - /// Note: the following maps could be ScopedSets, but it should be easier to work - /// deleted functions in if they are maps, since the value false can be inserted - /// at the current scope without affecting outer scopes or requiring copies. - TypeMap copyable, assignable, constructable, destructable; + + InitTweak::ManagedTypes managedTypes; std::vector< FuncData > data; }; /// generates routines for tuple types. - /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit - /// or anything we currently have that supports adding new declarations for visitors - class AutogenTupleRoutines : public GenPoly::DeclMutator { - public: - typedef GenPoly::DeclMutator Parent; - using Parent::mutate; - - virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); - - virtual Type * mutate( TupleType *tupleType ); - - virtual CompoundStmt * mutate( CompoundStmt *compoundStmt ); + struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef, public WithGuards, public WithShortCircuiting { + void previsit( FunctionDecl * functionDecl ); + + void postvisit( TupleType * tupleType ); + + void previsit( CompoundStmt * compoundStmt ); private: @@ -112,14 +90,128 @@ void autogenerateRoutines( std::list< Declaration * > &translationUnit ) { - AutogenerateRoutines generator; - acceptAndAdd( translationUnit, generator ); + PassVisitor generator; + acceptAll( translationUnit, generator ); // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc. // AutogenTupleRoutines tupleGenerator; - // tupleGenerator.mutateDeclarationList( translationUnit ); + // acceptAll( translationUnit, tupleGenerator ); + } + + //============================================================================================= + // FuncGenerator definitions + //============================================================================================= + class FuncGenerator { + public: + std::list< Declaration * > definitions, forwards; + + FuncGenerator( Type * type, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : type( type ), data( data ), functionNesting( functionNesting ), indexer( indexer ) {} + + virtual bool shouldAutogen() const = 0; + void genStandardFuncs(); + virtual void genFieldCtors() = 0; + protected: + Type * type; + const std::vector< FuncData > & data; + unsigned int functionNesting; + SymTab::Indexer & indexer; + + virtual void genFuncBody( FunctionDecl * dcl ) = 0; + virtual bool isConcurrentType() const = 0; + + void resolve( FunctionDecl * dcl ); + void generatePrototypes( std::list< FunctionDecl * > & newFuncs ); + }; + + class StructFuncGenerator : public FuncGenerator { + StructDecl * aggregateDecl; + public: + StructFuncGenerator( StructDecl * aggregateDecl, StructInstType * refType, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {} + + virtual bool shouldAutogen() const override; + virtual bool isConcurrentType() const override; + + virtual void genFuncBody( FunctionDecl * dcl ) override; + virtual void genFieldCtors() override; + + private: + /// generates a single struct member operation (constructor call, destructor call, assignment call) + void makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ); + + /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies + template + void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ); + + /// generate the body of a constructor which takes parameters that match fields, e.g. + /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. + template + void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ); + }; + + class UnionFuncGenerator : public FuncGenerator { + UnionDecl * aggregateDecl; + public: + UnionFuncGenerator( UnionDecl * aggregateDecl, UnionInstType * refType, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {} + + virtual bool shouldAutogen() const override; + virtual bool isConcurrentType() const override; + + virtual void genFuncBody( FunctionDecl * dcl ) override; + virtual void genFieldCtors() override; + + private: + /// generates a single struct member operation (constructor call, destructor call, assignment call) + template + void makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ); + + /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies + template + void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ); + + /// generate the body of a constructor which takes parameters that match fields, e.g. + /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. + template + void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ); + }; + + class EnumFuncGenerator : public FuncGenerator { + public: + EnumFuncGenerator( EnumInstType * refType, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ) {} + + virtual bool shouldAutogen() const override; + virtual bool isConcurrentType() const override; + + virtual void genFuncBody( FunctionDecl * dcl ) override; + virtual void genFieldCtors() override; + + private: + }; + + class TypeFuncGenerator : public FuncGenerator { + TypeDecl * typeDecl; + public: + TypeFuncGenerator( TypeDecl * typeDecl, TypeInstType * refType, const std::vector & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), typeDecl( typeDecl ) {} + + virtual bool shouldAutogen() const override; + virtual void genFuncBody( FunctionDecl * dcl ) override; + virtual bool isConcurrentType() const override; + virtual void genFieldCtors() override; + }; + + //============================================================================================= + // helper functions + //============================================================================================= + void generateFunctions( FuncGenerator & gen, std::list< Declaration * > & declsToAdd ) { + if ( ! gen.shouldAutogen() ) return; + + // generate each of the functions based on the supplied FuncData objects + gen.genStandardFuncs(); + gen.genFieldCtors(); + + declsToAdd.splice( declsToAdd.end(), gen.forwards ); + declsToAdd.splice( declsToAdd.end(), gen.definitions ); } bool isUnnamedBitfield( ObjectDecl * obj ) { - return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL; + return obj != nullptr && obj->name == "" && obj->bitfieldWidth != nullptr; } @@ -127,16 +219,27 @@ void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) { FunctionDecl * decl = functionDecl->clone(); - delete decl->get_statements(); - decl->set_statements( NULL ); + delete decl->statements; + decl->statements = nullptr; declsToAdd.push_back( decl ); decl->fixUniqueId(); } + const std::list< TypeDecl * > getGenericParams( Type * t ) { + std::list< TypeDecl * > * ret = nullptr; + if ( StructInstType * inst = dynamic_cast< StructInstType * > ( t ) ) { + ret = inst->get_baseParameters(); + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) { + ret = inst->get_baseParameters(); + } + return ret ? *ret : std::list< TypeDecl * >(); + } + /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *) FunctionType * genDefaultType( Type * paramType ) { + const auto & typeParams = getGenericParams( paramType ); FunctionType *ftype = new FunctionType( Type::Qualifiers(), false ); + cloneAll( typeParams, ftype->forall ); ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr ); - ftype->get_parameters().push_back( dstParam ); - + ftype->parameters.push_back( dstParam ); return ftype; } @@ -146,5 +249,5 @@ FunctionType *ftype = genDefaultType( paramType ); ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); - ftype->get_parameters().push_back( srcParam ); + ftype->parameters.push_back( srcParam ); return ftype; } @@ -154,5 +257,5 @@ FunctionType *ftype = genCopyType( paramType ); ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); - ftype->get_returnVals().push_back( returnVal ); + ftype->returnVals.push_back( returnVal ); return ftype; } @@ -171,145 +274,124 @@ } - /// inserts base type of first argument into map if pred(funcDecl) is true - void insert( FunctionDecl *funcDecl, TypeMap & map, FunctionDecl * (*pred)(Declaration *) ) { - // insert type into constructable, etc. map if appropriate - if ( pred( funcDecl ) ) { - FunctionType * ftype = funcDecl->get_functionType(); - assert( ! ftype->get_parameters().empty() ); - Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() ); - assert( t ); - map.insert( Mangler::mangleType( t ), true ); - } - } - - /// using map and t, determines if is constructable, etc. - bool lookup( const TypeMap & map, Type * t ) { - assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() ); - if ( dynamic_cast< PointerType * >( t ) ) { - // will need more complicated checking if we want this to work with pointer types, since currently - return true; - } else if ( ArrayType * at = dynamic_cast< ArrayType * >( t ) ) { - // an array's constructor, etc. is generated on the fly based on the base type's constructor, etc. - return lookup( map, at->get_base() ); - } - TypeMap::const_iterator it = map.find( Mangler::mangleType( t ) ); - if ( it != map.end() ) return it->second; - // something that does not appear in the map is by default not constructable, etc. - return false; - } - - /// using map and aggr, examines each member to determine if constructor, etc. should be generated - template - bool shouldGenerate( const TypeMap & map, const Container & container ) { - for ( Type * t : container ) { - if ( ! lookup( map, t ) ) return false; - } - return true; - } - - /// data structure for abstracting the generation of special functions - template< typename OutputIterator, typename Container > - struct FuncGenerator { - const Container & container; - Type *refType; - unsigned int functionNesting; - const std::list< TypeDecl* > & typeParams; - OutputIterator out; - FuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : container( container ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {} - - /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map. - void gen( const FuncData & data, bool concurrent_type ) { - if ( ! shouldGenerate( data.map, container ) ) return; - FunctionType * ftype = data.genType( refType ); - - if ( concurrent_type && CodeGen::isDestructor( data.fname ) ) { + Type * declToType( Declaration * decl ) { + if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { + return dwt->get_type(); + } + return nullptr; + } + + Type * declToTypeDeclBase( Declaration * decl ) { + if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) { + return td->base; + } + return nullptr; + } + + //============================================================================================= + // FuncGenerator member definitions + //============================================================================================= + void FuncGenerator::genStandardFuncs() { + std::list< FunctionDecl * > newFuncs; + generatePrototypes( newFuncs ); + + for ( FunctionDecl * dcl : newFuncs ) { + genFuncBody( dcl ); + if ( CodeGen::isAssignment( dcl->name ) ) { + // assignment needs to return a value + FunctionType * assignType = dcl->type; + assert( assignType->parameters.size() == 2 ); + assert( assignType->returnVals.size() == 1 ); + ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() ); + dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) ); + } + resolve( dcl ); + } + } + + void FuncGenerator::generatePrototypes( std::list< FunctionDecl * > & newFuncs ) { + bool concurrent_type = isConcurrentType(); + for ( const FuncData & d : data ) { + // generate a function (?{}, ?=?, ^?{}) based on the current FuncData. + FunctionType * ftype = d.genType( type ); + + // destructor for concurrent type must be mutex + if ( concurrent_type && CodeGen::isDestructor( d.fname ) ) { ftype->parameters.front()->get_type()->set_mutex( true ); } - cloneAll( typeParams, ftype->forall ); - *out++ = genFunc( data.fname, ftype, functionNesting ); - data.map.insert( Mangler::mangleType( refType ), true ); - } - }; - - template< typename OutputIterator, typename Container > - FuncGenerator makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) { - return FuncGenerator( container, refType, functionNesting, typeParams, out ); - } - - /// generates a single enumeration assignment expression - ApplicationExpr * genEnumAssign( FunctionType * ftype, FunctionDecl * assignDecl ) { - // enum copy construct and assignment is just C-style assignment. - // this looks like a bad recursive call, but code gen will turn it into - // a C-style assignment. - // This happens before function pointer type conversion, so need to do it manually here - // NOTE: ftype is not necessarily the functionType belonging to assignDecl - ftype is the - // type of the function that this expression is being generated for (so that the correct - // parameters) are using in the variable exprs - assert( ftype->get_parameters().size() == 2 ); - ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); - ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); - - VariableExpr * assignVarExpr = new VariableExpr( assignDecl ); - Type * assignVarExprType = assignVarExpr->get_result(); - assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType ); - assignVarExpr->set_result( assignVarExprType ); - ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr ); - assignExpr->get_args().push_back( new VariableExpr( dstParam ) ); - assignExpr->get_args().push_back( new VariableExpr( srcParam ) ); - return assignExpr; - } - - // E ?=?(E volatile*, int), - // ?=?(E _Atomic volatile*, int); - void makeEnumFunctions( EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) { - - // T ?=?(E *, E); - FunctionType *assignType = genAssignType( refType ); - - // void ?{}(E *); void ^?{}(E *); - FunctionType * ctorType = genDefaultType( refType->clone() ); - FunctionType * dtorType = genDefaultType( refType->clone() ); - - // void ?{}(E *, E); - FunctionType *copyCtorType = genCopyType( refType->clone() ); - - // add unused attribute to parameters of default constructor and destructor - ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); - dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); - - // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)? - // right now these cases work, but that might change. - - // xxx - Temporary: make these functions intrinsic so they codegen as C assignment. - // Really they're something of a cross between instrinsic and autogen, so should - // probably make a new linkage type - FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting, true ); - FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting, true ); - FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting, true ); - FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting, true ); - - // body is either return stmt or expr stmt - assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, genEnumAssign( assignType, assignDecl ) ) ); - copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, genEnumAssign( copyCtorType, assignDecl ) ) ); - - declsToAdd.push_back( ctorDecl ); - declsToAdd.push_back( copyCtorDecl ); - declsToAdd.push_back( dtorDecl ); - declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return - } - - /// generates a single struct member operation (constructor call, destructor call, assignment call) - void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) { + newFuncs.push_back( genFunc( d.fname, ftype, functionNesting ) ); + } + } + + void FuncGenerator::resolve( FunctionDecl * dcl ) { + try { + ResolvExpr::resolveDecl( dcl, indexer ); + if ( functionNesting == 0 ) { + // forward declare if top-level struct, so that + // type is complete as soon as its body ends + // Note: this is necessary if we want structs which contain + // generic (otype) structs as members. + addForwardDecl( dcl, forwards ); + } + definitions.push_back( dcl ); + indexer.addId( dcl ); + } catch ( SemanticError err ) { + // okay if decl does not resolve - that means the function should not be generated + delete dcl; + } + } + + bool StructFuncGenerator::shouldAutogen() const { + // Builtins do not use autogeneration. + return ! aggregateDecl->linkage.is_builtin; + } + bool StructFuncGenerator::isConcurrentType() const { return aggregateDecl->is_thread() || aggregateDecl->is_monitor(); } + + void StructFuncGenerator::genFuncBody( FunctionDecl * dcl ) { + // generate appropriate calls to member ctor, assignment + // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor + if ( ! CodeGen::isDestructor( dcl->name ) ) { + makeFunctionBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), dcl ); + } else { + makeFunctionBody( aggregateDecl->members.rbegin(), aggregateDecl->members.rend(), dcl, false ); + } + } + + void StructFuncGenerator::genFieldCtors() { + // field ctors are only generated if default constructor and copy constructor are both generated + unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->name ); } ); + + // Field constructors are only generated if default and copy constructor + // are generated, since they need access to both + if ( numCtors != 2 ) return; + + // create constructors which take each member type as a parameter. + // for example, for struct A { int x, y; }; generate + // void ?{}(A *, int) and void ?{}(A *, int, int) + FunctionType * memCtorType = genDefaultType( type ); + for ( Declaration * member : aggregateDecl->members ) { + DeclarationWithType * field = strict_dynamic_cast( member ); + if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) { + // don't make a function whose parameter is an unnamed bitfield + continue; + } + memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ) ); + FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); + makeFieldCtorBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), ctor ); + resolve( ctor ); + } + delete memCtorType; + } + + void StructFuncGenerator::makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward ) { InitTweak::InitExpander srcParam( src ); // assign to destination - Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) ); - genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); - } - - /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies + Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->base->clone() ) ); + genImplicitCall( srcParam, dstselect, func->name, back_inserter( func->statements->kids ), field, forward ); + } + template - void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) { + void StructFuncGenerator::makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward ) { for ( ; member != end; ++member ) { if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate @@ -321,41 +403,29 @@ } - if ( type->get_const() && func->get_name() == "?=?" ) { + if ( type->get_const() && CodeGen::isAssignment( func->name ) ) { // don't assign const members, but do construct/destruct continue; } - if ( field->get_name() == "" ) { - // don't assign to anonymous members - // xxx - this is a temporary fix. Anonymous members tie into - // our inheritance model. I think the correct way to handle this is to - // cast the structure to the type of the member and let the resolver - // figure out whether it's valid and have a pass afterwards that fixes - // the assignment to use pointer arithmetic with the offset of the - // member, much like how generic type members are handled. - continue; - } - assert( ! func->get_functionType()->get_parameters().empty() ); ObjectDecl * dstParam = dynamic_cast( func->get_functionType()->get_parameters().front() ); - ObjectDecl * srcParam = NULL; + ObjectDecl * srcParam = nullptr; if ( func->get_functionType()->get_parameters().size() == 2 ) { srcParam = dynamic_cast( func->get_functionType()->get_parameters().back() ); } + // srcParam may be NULL, in which case we have default ctor/dtor assert( dstParam ); - Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL; - makeStructMemberOp( dstParam, srcselect, field, func, forward ); + Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr; + makeMemberOp( dstParam, srcselect, field, func, forward ); } // if } // for - } // makeStructFunctionBody - - /// generate the body of a constructor which takes parameters that match fields, e.g. - /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. + } // makeFunctionBody + template - void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) { - FunctionType * ftype = func->get_functionType(); - std::list & params = ftype->get_parameters(); + void StructFuncGenerator::makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) { + FunctionType * ftype = func->type; + std::list & params = ftype->parameters; assert( params.size() >= 2 ); // should not call this function for default ctor, etc. @@ -369,21 +439,12 @@ // don't make a function whose parameter is an unnamed bitfield continue; - } else if ( field->get_name() == "" ) { - // don't assign to anonymous members - // xxx - this is a temporary fix. Anonymous members tie into - // our inheritance model. I think the correct way to handle this is to - // cast the structure to the type of the member and let the resolver - // figure out whether it's valid and have a pass afterwards that fixes - // the assignment to use pointer arithmetic with the offset of the - // member, much like how generic type members are handled. - continue; } else if ( parameter != params.end() ) { // matching parameter, initialize field with copy ctor Expression *srcselect = new VariableExpr(*parameter); - makeStructMemberOp( dstParam, srcselect, field, func ); + makeMemberOp( dstParam, srcselect, field, func ); ++parameter; } else { // no matching parameter, initialize field with default ctor - makeStructMemberOp( dstParam, NULL, field, func ); + makeMemberOp( dstParam, nullptr, field, func ); } } @@ -391,154 +452,47 @@ } - Type * declToType( Declaration * decl ) { - if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { - return dwt->get_type(); - } - return nullptr; - } - - /// generates struct constructors, destructor, and assignment functions - void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) { + bool UnionFuncGenerator::shouldAutogen() const { // Builtins do not use autogeneration. - if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA || - aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) { - return; - } - - // Make function polymorphic in same parameters as generic struct, if applicable - const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions - - // generate each of the functions based on the supplied FuncData objects - std::list< FunctionDecl * > newFuncs; - // structure that iterates aggregate decl members, returning their types - auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) ); - for ( const FuncData & d : data ) { - generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() ); - } - + return ! aggregateDecl->linkage.is_builtin; + } + + // xxx - is this right? + bool UnionFuncGenerator::isConcurrentType() const { return false; }; + + /// generate a single union assignment expression (using memcpy) + template< typename OutputIterator > + void UnionFuncGenerator::makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) { + UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) ); + copy->args.push_back( new AddressExpr( new VariableExpr( dstParam ) ) ); + copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) ); + copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) ); + *out++ = new ExprStmt( noLabels, copy ); + } + + /// generates the body of a union assignment/copy constructor/field constructor + void UnionFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) { + FunctionType * ftype = funcDecl->type; + if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) { + assert( ftype->parameters.size() == 2 ); + ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() ); + ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() ); + makeMemberOp( srcParam, dstParam, back_inserter( funcDecl->statements->kids ) ); + } else { + // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings + assert( ftype->parameters.size() == 1 ); + ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() ); + dstParam->attributes.push_back( new Attribute( "unused" ) ); + } + } + + /// generate the body of a constructor which takes parameters that match fields, e.g. + /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields. + void UnionFuncGenerator::genFieldCtors() { // field ctors are only generated if default constructor and copy constructor are both generated - unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } ); - - if ( functionNesting == 0 ) { - // forward declare if top-level struct, so that - // type is complete as soon as its body ends - // Note: this is necessary if we want structs which contain - // generic (otype) structs as members. - for ( FunctionDecl * dcl : newFuncs ) { - addForwardDecl( dcl, declsToAdd ); - } - } - - for ( FunctionDecl * dcl : newFuncs ) { - // generate appropriate calls to member ctor, assignment - // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor - if ( ! CodeGen::isDestructor( dcl->get_name() ) ) { - makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl ); - } else { - makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false ); - } - if ( CodeGen::isAssignment( dcl->get_name() ) ) { - // assignment needs to return a value - FunctionType * assignType = dcl->get_functionType(); - assert( assignType->get_parameters().size() == 2 ); - ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() ); - dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); - } - declsToAdd.push_back( dcl ); - } - - // create constructors which take each member type as a parameter. - // for example, for struct A { int x, y; }; generate - // void ?{}(A *, int) and void ?{}(A *, int, int) + unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } ); + // Field constructors are only generated if default and copy constructor // are generated, since they need access to both - if ( numCtors == 2 ) { - FunctionType * memCtorType = genDefaultType( refType ); - cloneAll( typeParams, memCtorType->get_forall() ); - for ( std::list::iterator i = aggregateDecl->get_members().begin(); i != aggregateDecl->get_members().end(); ++i ) { - DeclarationWithType * member = dynamic_cast( *i ); - assert( member ); - if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( member ) ) ) { - // don't make a function whose parameter is an unnamed bitfield - continue; - } else if ( member->get_name() == "" ) { - // don't assign to anonymous members - // xxx - this is a temporary fix. Anonymous members tie into - // our inheritance model. I think the correct way to handle this is to - // cast the structure to the type of the member and let the resolver - // figure out whether it's valid/choose the correct unnamed member - continue; - } - memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) ); - FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); - makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor ); - declsToAdd.push_back( ctor ); - } - delete memCtorType; - } - } - - /// generate a single union assignment expression (using memcpy) - template< typename OutputIterator > - void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) { - UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) ); - copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) ); - copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) ); - copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) ); - *out++ = new ExprStmt( noLabels, copy ); - } - - /// generates the body of a union assignment/copy constructor/field constructor - void makeUnionAssignBody( FunctionDecl * funcDecl ) { - FunctionType * ftype = funcDecl->get_functionType(); - assert( ftype->get_parameters().size() == 2 ); - ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); - ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); - - makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) ); - if ( CodeGen::isAssignment( funcDecl->get_name() ) ) { - // also generate return statement in assignment - funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); - } - } - - /// generates union constructors, destructors, and assignment operator - void makeUnionFunctions( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) { - // Make function polymorphic in same parameters as generic union, if applicable - const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions - - // default ctor/dtor need only first parameter - // void ?{}(T *); void ^?{}(T *); - FunctionType *ctorType = genDefaultType( refType ); - FunctionType *dtorType = genDefaultType( refType ); - - // copy ctor needs both parameters - // void ?{}(T *, T); - FunctionType *copyCtorType = genCopyType( refType ); - - // assignment needs both and return value - // T ?=?(T *, T); - FunctionType *assignType = genAssignType( refType ); - - cloneAll( typeParams, ctorType->get_forall() ); - cloneAll( typeParams, dtorType->get_forall() ); - cloneAll( typeParams, copyCtorType->get_forall() ); - cloneAll( typeParams, assignType->get_forall() ); - - // add unused attribute to parameters of default constructor and destructor - ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); - dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) ); - - // Routines at global scope marked "static" to prevent multiple definitions is separate translation units - // because each unit generates copies of the default routines for each aggregate. - FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting ); - FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting ); - FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting ); - FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting ); - - makeUnionAssignBody( assignDecl ); - - // body of assignment and copy ctor is the same - makeUnionAssignBody( copyCtorDecl ); + if ( numCtors != 2 ) return; // create a constructor which takes the first member type as a parameter. @@ -546,60 +500,114 @@ // void ?{}(A *, int) // This is to mimic C's behaviour which initializes the first member of the union. - std::list memCtors; - for ( Declaration * member : aggregateDecl->get_members() ) { - if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) { - ObjectDecl * srcParam = new ObjectDecl( "src", Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ); - - FunctionType * memCtorType = ctorType->clone(); - memCtorType->get_parameters().push_back( srcParam ); - FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting ); - - makeUnionAssignBody( ctor ); - memCtors.push_back( ctor ); - // only generate a ctor for the first field + FunctionType * memCtorType = genDefaultType( type ); + for ( Declaration * member : aggregateDecl->members ) { + DeclarationWithType * field = strict_dynamic_cast( member ); + if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) { + // don't make a function whose parameter is an unnamed bitfield break; } - } - - declsToAdd.push_back( ctorDecl ); - declsToAdd.push_back( copyCtorDecl ); - declsToAdd.push_back( dtorDecl ); - declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return - declsToAdd.splice( declsToAdd.end(), memCtors ); - } - + memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, field->get_type()->clone(), nullptr ) ); + FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); + ObjectDecl * srcParam = strict_dynamic_cast( ctor->type->parameters.back() ); + srcParam->fixUniqueId(); + ObjectDecl * dstParam = InitTweak::getParamThis( ctor->type ); + makeMemberOp( srcParam, dstParam, back_inserter( ctor->statements->kids ) ); + resolve( ctor ); + // only generate one field ctor for unions + break; + } + delete memCtorType; + } + + void EnumFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) { + // xxx - Temporary: make these functions intrinsic so they codegen as C assignment. + // Really they're something of a cross between instrinsic and autogen, so should + // probably make a new linkage type + funcDecl->linkage = LinkageSpec::Intrinsic; + FunctionType * ftype = funcDecl->type; + if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) { + assert( ftype->parameters.size() == 2 ); + ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() ); + ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() ); + + // enum copy construct and assignment is just C-style assignment. + // this looks like a bad recursive call, but code gen will turn it into + // a C-style assignment. + // This happens before function pointer type conversion, so need to do it manually here + ApplicationExpr * callExpr = new ApplicationExpr( VariableExpr::functionPointer( funcDecl ) ); + callExpr->get_args().push_back( new VariableExpr( dstParam ) ); + callExpr->get_args().push_back( new VariableExpr( srcParam ) ); + funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) ); + } else { + // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings + assert( ftype->parameters.size() == 1 ); + ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() ); + dstParam->attributes.push_back( new Attribute( "unused" ) ); + } + } + + bool EnumFuncGenerator::shouldAutogen() const { return true; } + bool EnumFuncGenerator::isConcurrentType() const { return false; } + // enums do not have field constructors + void EnumFuncGenerator::genFieldCtors() {} + + bool TypeFuncGenerator::shouldAutogen() const { return true; }; + + void TypeFuncGenerator::genFuncBody( FunctionDecl * dcl ) { + FunctionType * ftype = dcl->type; + assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() ); + DeclarationWithType * dst = ftype->parameters.front(); + DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr; + // generate appropriate calls to member ctor, assignment + UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) ); + expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) ); + if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) ); + dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) ); + }; + + // xxx - should reach in and determine if base type is concurrent? + bool TypeFuncGenerator::isConcurrentType() const { return false; }; + + // opaque types do not have field constructors + void TypeFuncGenerator::genFieldCtors() {}; + + //============================================================================================= + // Visitor definitions + //============================================================================================= AutogenerateRoutines::AutogenerateRoutines() { // the order here determines the order that these functions are generated. // assignment should come last since it uses copy constructor in return. - data.push_back( FuncData( "?{}", genDefaultType, constructable ) ); - data.push_back( FuncData( "?{}", genCopyType, copyable ) ); - data.push_back( FuncData( "^?{}", genDefaultType, destructable ) ); - data.push_back( FuncData( "?=?", genAssignType, assignable ) ); - } - - void AutogenerateRoutines::visit( EnumDecl *enumDecl ) { - if ( ! enumDecl->get_members().empty() ) { - EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() ); - // enumInst->set_baseEnum( enumDecl ); - makeEnumFunctions( enumInst, functionNesting, declsToAddAfter ); - } - } - - void AutogenerateRoutines::visit( StructDecl *structDecl ) { - if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) { - StructInstType structInst( Type::Qualifiers(), structDecl->get_name() ); - for ( TypeDecl * typeDecl : structDecl->get_parameters() ) { - // need to visit assertions so that they are added to the appropriate maps - acceptAll( typeDecl->get_assertions(), *this ); - structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) ); - } + data.emplace_back( "?{}", genDefaultType ); + data.emplace_back( "?{}", genCopyType ); + data.emplace_back( "^?{}", genDefaultType ); + data.emplace_back( "?=?", genAssignType ); + } + + void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) { + // must visit children (enum constants) to add them to the indexer + if ( enumDecl->has_body() ) { + EnumInstType enumInst( Type::Qualifiers(), enumDecl->get_name() ); + enumInst.set_baseEnum( enumDecl ); + EnumFuncGenerator gen( &enumInst, data, functionNesting, indexer ); + generateFunctions( gen, declsToAddAfter ); + } + } + + void AutogenerateRoutines::previsit( StructDecl * structDecl ) { + visit_children = false; + if ( structDecl->has_body() ) { + StructInstType structInst( Type::Qualifiers(), structDecl->name ); structInst.set_baseStruct( structDecl ); - makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data ); - structsDone.insert( structDecl->get_name() ); + for ( TypeDecl * typeDecl : structDecl->parameters ) { + structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) ); + } + StructFuncGenerator gen( structDecl, &structInst, data, functionNesting, indexer ); + generateFunctions( gen, declsToAddAfter ); } // if } - void AutogenerateRoutines::visit( UnionDecl *unionDecl ) { - if ( ! unionDecl->get_members().empty() ) { + void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) { + visit_children = false; + if ( unionDecl->has_body() ) { UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() ); unionInst.set_baseUnion( unionDecl ); @@ -607,114 +615,48 @@ unionInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) ); } - makeUnionFunctions( unionDecl, &unionInst, functionNesting, declsToAddAfter ); + UnionFuncGenerator gen( unionDecl, &unionInst, data, functionNesting, indexer ); + generateFunctions( gen, declsToAddAfter ); } // if } - Type * declToTypeDeclBase( Declaration * decl ) { - if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) { - return td->base; - } - return nullptr; - } - // generate ctor/dtors/assign for typedecls, e.g., otype T = int *; - void AutogenerateRoutines::visit( TypeDecl *typeDecl ) { + void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) { + visit_children = false; if ( ! typeDecl->base ) return; - // generate each of the functions based on the supplied FuncData objects - std::list< FunctionDecl * > newFuncs; - std::list< Declaration * > tds { typeDecl }; - std::list< TypeDecl * > typeParams; TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl ); - auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) ); - for ( const FuncData & d : data ) { - generator.gen( d, false ); - } - - if ( functionNesting == 0 ) { - // forward declare if top-level struct, so that - // type is complete as soon as its body ends - // Note: this is necessary if we want structs which contain - // generic (otype) structs as members. - for ( FunctionDecl * dcl : newFuncs ) { - addForwardDecl( dcl, declsToAddAfter ); - } - } - - for ( FunctionDecl * dcl : newFuncs ) { - FunctionType * ftype = dcl->type; - assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() ); - DeclarationWithType * dst = ftype->parameters.front(); - DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr; - // generate appropriate calls to member ctor, assignment - // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor - UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) ); - expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) ); - if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) ); - dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) ); - if ( CodeGen::isAssignment( dcl->get_name() ) ) { - // assignment needs to return a value - FunctionType * assignType = dcl->type; - assert( assignType->parameters.size() == 2 ); - ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() ); - dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); - } - declsToAddAfter.push_back( dcl ); - } - } - - void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) { - for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) { - statements.insert( i, new DeclStmt( noLabels, *decl ) ); - } // for - declsToAdd.clear(); - } - - void AutogenerateRoutines::visit( FunctionType *) { + TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer ); + generateFunctions( gen, declsToAddAfter ); + } + + void AutogenerateRoutines::previsit( FunctionType *) { // ensure that we don't add assignment ops for types defined as part of the function - } - - void AutogenerateRoutines::visit( PointerType *) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( PointerType *) { // ensure that we don't add assignment ops for types defined as part of the pointer - } - - void AutogenerateRoutines::visit( TraitDecl *) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( TraitDecl * ) { // ensure that we don't add assignment ops for types defined as part of the trait - } - - template< typename StmtClass > - inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) { - std::set< std::string > oldStructs = structsDone; - addVisit( stmt, *this ); - structsDone = oldStructs; - } - - void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) { + visit_children = false; // record the existence of this function as appropriate - insert( functionDecl, constructable, InitTweak::isDefaultConstructor ); - insert( functionDecl, assignable, InitTweak::isAssignment ); - insert( functionDecl, copyable, InitTweak::isCopyConstructor ); - insert( functionDecl, destructable, InitTweak::isDestructor ); - - maybeAccept( functionDecl->get_functionType(), *this ); + managedTypes.handleDWT( functionDecl ); + + maybeAccept( functionDecl->type, *visitor ); functionNesting += 1; - maybeAccept( functionDecl->get_statements(), *this ); + maybeAccept( functionDecl->statements, *visitor ); functionNesting -= 1; } - void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) { - constructable.beginScope(); - assignable.beginScope(); - copyable.beginScope(); - destructable.beginScope(); - visitStatement( compoundStmt ); - constructable.endScope(); - assignable.endScope(); - copyable.endScope(); - destructable.endScope(); - } - - void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) { - visitStatement( switchStmt ); + void AutogenerateRoutines::previsit( CompoundStmt * ) { + GuardScope( managedTypes ); + GuardScope( structsDone ); } @@ -734,8 +676,7 @@ } - Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) { - tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) ); + void AutogenTupleRoutines::postvisit( TupleType * tupleType ) { std::string mangleName = SymTab::Mangler::mangleType( tupleType ); - if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType; + if ( seenTuples.find( mangleName ) != seenTuples.end() ) return; seenTuples.insert( mangleName ); @@ -755,5 +696,5 @@ if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) { if ( ! done.count( ty->get_baseType() ) ) { - TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Any ); + TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Dtype, true ); TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl ); newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr, @@ -785,25 +726,20 @@ makeTupleFunctionBody( dtorDecl ); - addDeclaration( ctorDecl ); - addDeclaration( copyCtorDecl ); - addDeclaration( dtorDecl ); - addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return - - return tupleType; - } - - DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) { - functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); + declsToAddBefore.push_back( ctorDecl ); + declsToAddBefore.push_back( copyCtorDecl ); + declsToAddBefore.push_back( dtorDecl ); + declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return + } + + void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) { + visit_children = false; + maybeAccept( functionDecl->type, *visitor ); functionNesting += 1; - functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + maybeAccept( functionDecl->statements, *visitor ); functionNesting -= 1; - return functionDecl; - } - - CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) { - seenTuples.beginScope(); - compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) ); - seenTuples.endScope(); - return compoundStmt; + } + + void AutogenTupleRoutines::previsit( CompoundStmt * ) { + GuardScope( seenTuples ); } } // SymTab Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Autogen.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -19,4 +19,5 @@ #include // for string +#include "CodeGen/OperatorTable.h" #include "Common/UniqueName.h" // for UniqueName #include "InitTweak/InitTweak.h" // for InitExpander @@ -44,6 +45,12 @@ extern FunctionDecl * dereferenceOperator; - // temporary + // generate the type of an assignment function for paramType FunctionType * genAssignType( Type * paramType ); + + // generate the type of a default constructor or destructor for paramType + FunctionType * genDefaultType( Type * paramType ); + + // generate the type of a copy constructor for paramType + FunctionType * genCopyType( Type * paramType ); /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. @@ -54,8 +61,18 @@ /// optionally returns a statement which must be inserted prior to the containing loop, if there is one template< typename OutputIterator > - Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) { + Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) { + bool isReferenceCtorDtor = false; + if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) { + // reference constructors are essentially application of the rebind operator. + // apply & to both arguments, do not need a cast + fname = "?=?"; + dstParam = new AddressExpr( dstParam ); + addCast = false; + isReferenceCtorDtor = true; + } + // want to be able to generate assignment, ctor, and dtor generically, // so fname is either ?=?, ?{}, or ^?{} - UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) ); + UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) ); if ( addCast ) { @@ -72,10 +89,19 @@ dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) ); } - fExpr->get_args().push_back( dstParam ); + fExpr->args.push_back( dstParam ); Statement * listInit = srcParam.buildListInit( fExpr ); - std::list< Expression * > args = *++srcParam; - fExpr->get_args().splice( fExpr->get_args().end(), args ); + // fetch next set of arguments + ++srcParam; + + // return if adding reference fails - will happen on default constructor and destructor + if ( isReferenceCtorDtor && ! srcParam.addReference() ) { + delete fExpr; + return listInit; + } + + std::list< Expression * > args = *srcParam; + fExpr->args.splice( fExpr->args.end(), args ); *out++ = new ExprStmt( noLabels, fExpr ); @@ -99,5 +125,5 @@ // generate: for ( int i = 0; i < N; ++i ) begin = new ConstantExpr( Constant::from_int( 0 ) ); - end = array->get_dimension()->clone(); + end = array->dimension->clone(); cmp = new NameExpr( "?= 0; --i ) begin = new UntypedExpr( new NameExpr( "?-?" ) ); - ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); - ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); + ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() ); + ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); end = new ConstantExpr( Constant::from_int( 0 ) ); cmp = new NameExpr( "?>=?" ); @@ -115,29 +141,29 @@ UntypedExpr *cond = new UntypedExpr( cmp ); - cond->get_args().push_back( new VariableExpr( index ) ); - cond->get_args().push_back( end ); + cond->args.push_back( new VariableExpr( index ) ); + cond->args.push_back( end ); UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new VariableExpr( index ) ); + inc->args.push_back( new VariableExpr( index ) ); UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); - dstIndex->get_args().push_back( dstParam ); - dstIndex->get_args().push_back( new VariableExpr( index ) ); + dstIndex->args.push_back( dstParam ); + dstIndex->args.push_back( new VariableExpr( index ) ); dstParam = dstIndex; // srcParam must keep track of the array indices to build the // source parameter and/or array list initializer - srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); + srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() ); // for stmt's body, eventually containing call CompoundStmt * body = new CompoundStmt( noLabels ); - Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward ); // block containing for stmt and index variable std::list initList; CompoundStmt * block = new CompoundStmt( noLabels ); - block->get_kids().push_back( new DeclStmt( noLabels, index ) ); + block->push_back( new DeclStmt( noLabels, index ) ); if ( listInit ) block->get_kids().push_back( listInit ); - block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); *out++ = block; @@ -145,5 +171,5 @@ template< typename OutputIterator > - Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { + Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); @@ -159,5 +185,5 @@ /// ImplicitCtorDtorStmt node. template< typename OutputIterator > - void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { + void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { ObjectDecl *obj = dynamic_cast( decl ); assert( obj ); @@ -167,5 +193,5 @@ bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ); std::list< Statement * > stmts; - genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); + genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward ); // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/FixFunction.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -26,68 +26,40 @@ FixFunction::FixFunction() : isVoid( false ) {} - DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) { - ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() ); - functionDecl->get_attributes().clear(); - // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr - functionDecl->set_type( functionDecl->get_type()->clone() ); + + DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) { + // can't delete function type because it may contain assertions, so transfer ownership to new object + ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes ); + functionDecl->attributes.clear(); + functionDecl->type = nullptr; delete functionDecl; return pointer; } - Type * FixFunction::mutate(VoidType *voidType) { - isVoid = true; - return voidType; - } - - Type * FixFunction::mutate(BasicType *basicType) { - return basicType; - } - - Type * FixFunction::mutate(PointerType *pointerType) { - return pointerType; - } - - Type * FixFunction::mutate(ArrayType *arrayType) { + Type * FixFunction::postmutate(ArrayType *arrayType) { // need to recursively mutate the base type in order for multi-dimensional arrays to work. - PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() ); + PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic ); + arrayType->base = nullptr; + arrayType->dimension = nullptr; delete arrayType; return pointerType; } - Type * FixFunction::mutate(StructInstType *aggregateUseType) { - return aggregateUseType; + void FixFunction::premutate(VoidType *) { + isVoid = true; } - Type * FixFunction::mutate(UnionInstType *aggregateUseType) { - return aggregateUseType; - } - - Type * FixFunction::mutate(EnumInstType *aggregateUseType) { - return aggregateUseType; - } - - Type * FixFunction::mutate(TraitInstType *aggregateUseType) { - return aggregateUseType; - } - - Type * FixFunction::mutate(TypeInstType *aggregateUseType) { - return aggregateUseType; - } - - Type * FixFunction::mutate(TupleType *tupleType) { - return tupleType; - } - - Type * FixFunction::mutate(VarArgsType *varArgsType) { - return varArgsType; - } - - Type * FixFunction::mutate(ZeroType *zeroType) { - return zeroType; - } - - Type * FixFunction::mutate(OneType *oneType) { - return oneType; - } + void FixFunction::premutate(FunctionDecl *) { visit_children = false; } + void FixFunction::premutate(ArrayType *) { visit_children = false; } + void FixFunction::premutate(BasicType *) { visit_children = false; } + void FixFunction::premutate(PointerType *) { visit_children = false; } + void FixFunction::premutate(StructInstType *) { visit_children = false; } + void FixFunction::premutate(UnionInstType *) { visit_children = false; } + void FixFunction::premutate(EnumInstType *) { visit_children = false; } + void FixFunction::premutate(TraitInstType *) { visit_children = false; } + void FixFunction::premutate(TypeInstType *) { visit_children = false; } + void FixFunction::premutate(TupleType *) { visit_children = false; } + void FixFunction::premutate(VarArgsType *) { visit_children = false; } + void FixFunction::premutate(ZeroType *) { visit_children = false; } + void FixFunction::premutate(OneType *) { visit_children = false; } } // namespace SymTab Index: src/SymTab/FixFunction.h =================================================================== --- src/SymTab/FixFunction.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/FixFunction.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -16,32 +16,32 @@ #pragma once -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/SynTree.h" // for Types +#include "Common/PassVisitor.h" // for PassVisitor +#include "SynTree/SynTree.h" // for Types namespace SymTab { /// Replaces function and array types by equivalent pointer types. - class FixFunction : public Mutator { + class FixFunction : public WithShortCircuiting { typedef Mutator Parent; public: FixFunction(); - bool get_isVoid() const { return isVoid; } - void set_isVoid( bool newValue ) { isVoid = newValue; } - private: - virtual DeclarationWithType* mutate(FunctionDecl *functionDecl); + void premutate(FunctionDecl *functionDecl); + DeclarationWithType* postmutate(FunctionDecl *functionDecl); - virtual Type* mutate(VoidType *voidType); - virtual Type* mutate(BasicType *basicType); - virtual Type* mutate(PointerType *pointerType); - virtual Type* mutate(ArrayType *arrayType); - virtual Type* mutate(StructInstType *aggregateUseType); - virtual Type* mutate(UnionInstType *aggregateUseType); - virtual Type* mutate(EnumInstType *aggregateUseType); - virtual Type* mutate(TraitInstType *aggregateUseType); - virtual Type* mutate(TypeInstType *aggregateUseType); - virtual Type* mutate(TupleType *tupleType); - virtual Type* mutate(VarArgsType *varArgsType); - virtual Type* mutate(ZeroType *zeroType); - virtual Type* mutate(OneType *oneType); + Type * postmutate(ArrayType * arrayType); + + void premutate(ArrayType * arrayType); + void premutate(VoidType * voidType); + void premutate(BasicType * basicType); + void premutate(PointerType * pointerType); + void premutate(StructInstType * aggregateUseType); + void premutate(UnionInstType * aggregateUseType); + void premutate(EnumInstType * aggregateUseType); + void premutate(TraitInstType * aggregateUseType); + void premutate(TypeInstType * aggregateUseType); + void premutate(TupleType * tupleType); + void premutate(VarArgsType * varArgsType); + void premutate(ZeroType * zeroType); + void premutate(OneType * oneType); bool isVoid; Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Indexer.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -40,17 +40,4 @@ namespace SymTab { - struct NewScope { - NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); } - ~NewScope() { indexer.leaveScope(); } - SymTab::Indexer & indexer; - }; - - template< typename TreeType, typename VisitorType > - inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) { - visitor.enterScope(); - maybeAccept( tree, visitor ); - visitor.leaveScope(); - } - typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable; typedef std::unordered_map< std::string, MangleTable > IdTable; @@ -198,9 +185,9 @@ } - Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {} - - Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {} - - Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) { + Indexer::Indexer() : tables( 0 ), scope( 0 ) {} + + Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {} + + Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) { that.tables = 0; } @@ -420,7 +407,7 @@ makeWritable(); - const std::string &name = decl->get_name(); + const std::string &name = decl->name; std::string mangleName; - if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) { + if ( LinkageSpec::isOverridable( decl->linkage ) ) { // mangle the name without including the appropriate suffix, so overridable routines are placed into the // same "bucket" as their user defined versions. @@ -431,5 +418,5 @@ // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage - if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) { + if ( ! LinkageSpec::isMangled( decl->linkage ) ) { // NOTE this is broken in Richard's original code in such a way that it never triggers (it // doesn't check decls that have the same manglename, and all C-linkage decls are defined to @@ -584,23 +571,25 @@ if ( doDebug ) { - std::cout << "--- Entering scope " << scope << std::endl; + std::cerr << "--- Entering scope " << scope << std::endl; } } void Indexer::leaveScope() { - using std::cout; + using std::cerr; assert( scope > 0 && "cannot leave initial scope" ); + if ( doDebug ) { + cerr << "--- Leaving scope " << scope << " containing" << std::endl; + } --scope; while ( tables && tables->scope > scope ) { if ( doDebug ) { - cout << "--- Leaving scope " << tables->scope << " containing" << std::endl; - dump( tables->idTable, cout ); - dump( tables->typeTable, cout ); - dump( tables->structTable, cout ); - dump( tables->enumTable, cout ); - dump( tables->unionTable, cout ); - dump( tables->traitTable, cout ); + dump( tables->idTable, cerr ); + dump( tables->typeTable, cerr ); + dump( tables->structTable, cerr ); + dump( tables->enumTable, cerr ); + dump( tables->unionTable, cerr ); + dump( tables->traitTable, cerr ); } Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Indexer.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -26,5 +26,5 @@ class Indexer { public: - explicit Indexer( bool useDebug = false ); + explicit Indexer(); Indexer( const Indexer &that ); @@ -76,4 +76,5 @@ void addTrait( TraitDecl *decl ); + bool doDebug = false; ///< Display debugging trace? private: struct Impl; @@ -81,5 +82,4 @@ Impl *tables; ///< Copy-on-write instance of table data structure unsigned long scope; ///< Scope index of this pointer - bool doDebug; ///< Display debugging trace? /// Takes a new ref to a table (returns null if null) Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Mangler.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:40:29 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Jun 28 15:31:00 2017 -// Update Count : 21 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Sep 25 15:49:26 2017 +// Update Count : 23 // #include "Mangler.h" @@ -31,12 +31,18 @@ namespace SymTab { - std::string Mangler::mangleType( Type *ty ) { - Mangler mangler( false, true ); + std::string Mangler::mangleType( Type * ty ) { + Mangler mangler( false, true, true ); maybeAccept( ty, mangler ); return mangler.get_mangleName(); } - Mangler::Mangler( bool mangleOverridable, bool typeMode ) - : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {} + std::string Mangler::mangleConcrete( Type* ty ) { + Mangler mangler( false, false, false ); + maybeAccept( ty, mangler ); + return mangler.get_mangleName(); + } + + Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ) + : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {} Mangler::Mangler( const Mangler &rhs ) : mangleName() { @@ -48,5 +54,5 @@ } - void Mangler::mangleDecl( DeclarationWithType *declaration ) { + void Mangler::mangleDecl( DeclarationWithType * declaration ) { bool wasTopLevel = isTopLevel; if ( isTopLevel ) { @@ -79,18 +85,18 @@ } - void Mangler::visit( ObjectDecl *declaration ) { + void Mangler::visit( ObjectDecl * declaration ) { mangleDecl( declaration ); } - void Mangler::visit( FunctionDecl *declaration ) { + void Mangler::visit( FunctionDecl * declaration ) { mangleDecl( declaration ); } - void Mangler::visit( VoidType *voidType ) { + void Mangler::visit( VoidType * voidType ) { printQualifiers( voidType ); mangleName << "v"; } - void Mangler::visit( BasicType *basicType ) { + void Mangler::visit( BasicType * basicType ) { static const char *btLetter[] = { "b", // Bool @@ -115,4 +121,6 @@ "Id", // DoubleImaginary "Ir", // LongDoubleImaginary + "w", // SignedInt128 + "Uw", // UnsignedInt128 }; @@ -121,5 +129,5 @@ } - void Mangler::visit( PointerType *pointerType ) { + void Mangler::visit( PointerType * pointerType ) { printQualifiers( pointerType ); mangleName << "P"; @@ -127,5 +135,5 @@ } - void Mangler::visit( ArrayType *arrayType ) { + void Mangler::visit( ArrayType * arrayType ) { // TODO: encode dimension printQualifiers( arrayType ); @@ -134,5 +142,5 @@ } - void Mangler::visit( ReferenceType *refType ) { + void Mangler::visit( ReferenceType * refType ) { printQualifiers( refType ); mangleName << "R"; @@ -149,5 +157,5 @@ } - void Mangler::visit( FunctionType *functionType ) { + void Mangler::visit( FunctionType * functionType ) { printQualifiers( functionType ); mangleName << "F"; @@ -160,48 +168,36 @@ } - void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) { + void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { printQualifiers( refType ); mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name(); - } - - void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) { - printQualifiers( refType ); - - std::ostringstream oldName( mangleName.str() ); - mangleName.clear(); - - mangleName << prefix << refType->get_name(); - - std::list< Expression* >& params = refType->get_parameters(); - if ( ! params.empty() ) { - mangleName << "_"; - for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { - TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); - assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); - maybeAccept( paramType->get_type(), *this ); + + if ( mangleGenericParams ) { + std::list< Expression* >& params = refType->get_parameters(); + if ( ! params.empty() ) { + mangleName << "_"; + for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { + TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); + assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str()); + maybeAccept( paramType->get_type(), *this ); + } + mangleName << "_"; } - mangleName << "_"; } - - oldName << mangleName.str().length() << mangleName.str(); - mangleName.str( oldName.str() ); - } - - void Mangler::visit( StructInstType *aggregateUseType ) { - if ( typeMode ) mangleGenericRef( aggregateUseType, "s" ); - else mangleRef( aggregateUseType, "s" ); - } - - void Mangler::visit( UnionInstType *aggregateUseType ) { - if ( typeMode ) mangleGenericRef( aggregateUseType, "u" ); - else mangleRef( aggregateUseType, "u" ); - } - - void Mangler::visit( EnumInstType *aggregateUseType ) { + } + + void Mangler::visit( StructInstType * aggregateUseType ) { + mangleRef( aggregateUseType, "s" ); + } + + void Mangler::visit( UnionInstType * aggregateUseType ) { + mangleRef( aggregateUseType, "u" ); + } + + void Mangler::visit( EnumInstType * aggregateUseType ) { mangleRef( aggregateUseType, "e" ); } - void Mangler::visit( TypeInstType *typeInst ) { + void Mangler::visit( TypeInstType * typeInst ) { VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); if ( varNum == varNums.end() ) { @@ -212,7 +208,4 @@ numStream << varNum->second.first; switch ( (TypeDecl::Kind )varNum->second.second ) { - case TypeDecl::Any: - mangleName << "t"; - break; case TypeDecl::Dtype: mangleName << "d"; @@ -231,27 +224,27 @@ } - void Mangler::visit( TupleType *tupleType ) { + void Mangler::visit( TupleType * tupleType ) { printQualifiers( tupleType ); mangleName << "T"; - acceptAll( tupleType->get_types(), *this ); + acceptAll( tupleType->types, *this ); mangleName << "_"; } - void Mangler::visit( VarArgsType *varArgsType ) { + void Mangler::visit( VarArgsType * varArgsType ) { printQualifiers( varArgsType ); mangleName << "VARGS"; } - void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) { + void Mangler::visit( ZeroType * ) { mangleName << "Z"; } - void Mangler::visit( __attribute__((unused)) OneType *oneType ) { + void Mangler::visit( OneType * ) { mangleName << "O"; } - void Mangler::visit( TypeDecl *decl ) { + void Mangler::visit( TypeDecl * decl ) { static const char *typePrefix[] = { "BT", "BD", "BF" }; - mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name(); + mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; } @@ -262,5 +255,5 @@ } - void Mangler::printQualifiers( Type *type ) { + void Mangler::printQualifiers( Type * type ) { // skip if not including qualifiers if ( typeMode ) return; @@ -270,9 +263,6 @@ int tcount = 0, dcount = 0, fcount = 0, vcount = 0; mangleName << "A"; - for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { + for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { switch ( (*i)->get_kind() ) { - case TypeDecl::Any: - tcount++; - break; case TypeDecl::Dtype: dcount++; @@ -287,7 +277,7 @@ assert( false ); } // switch - varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() ); - for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) { - Mangler sub_mangler( mangleOverridable, typeMode ); + varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); + for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { + Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams ); sub_mangler.nextVarNum = nextVarNum; sub_mangler.isTopLevel = false; @@ -307,4 +297,7 @@ mangleName << "V"; } // if + if ( type->get_mutex() ) { + mangleName << "M"; + } // if // Removed due to restrict not affecting function compatibility in GCC // if ( type->get_isRestrict() ) { @@ -312,6 +305,7 @@ // } // if if ( type->get_lvalue() ) { + // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues mangleName << "L"; - } // if + } if ( type->get_atomic() ) { mangleName << "A"; Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Mangler.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -30,7 +30,10 @@ /// Mangle syntax tree object; primary interface to clients template< typename SynTreeClass > - static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false ); + static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true ); /// Mangle a type name; secondary interface static std::string mangleType( Type* ty ); + /// Mangle ignoring generic type parameters + static std::string mangleConcrete( Type* ty ); + virtual void visit( ObjectDecl *declaration ); @@ -62,11 +65,11 @@ bool mangleOverridable; ///< Specially mangle overridable built-in methods bool typeMode; ///< Produce a unique mangled name for a type + bool mangleGenericParams; ///< Include generic parameters in name mangling if true - Mangler( bool mangleOverridable, bool typeMode ); + Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams ); Mangler( const Mangler & ); void mangleDecl( DeclarationWithType *declaration ); void mangleRef( ReferenceToType *refType, std::string prefix ); - void mangleGenericRef( ReferenceToType *refType, std::string prefix ); void printQualifiers( Type *type ); @@ -74,6 +77,6 @@ template< typename SynTreeClass > - std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode ) { - Mangler mangler( mangleOverridable, typeMode ); + std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) { + Mangler mangler( mangleOverridable, typeMode, mangleGenericParams ); maybeAccept( decl, mangler ); return mangler.get_mangleName(); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SymTab/Validate.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -56,4 +56,5 @@ #include "FixFunction.h" // for FixFunction #include "Indexer.h" // for Indexer +#include "InitTweak/GenInit.h" // for fixReturnStatements #include "InitTweak/InitTweak.h" // for isCtorDtorAssign #include "Parser/LinkageSpec.h" // for C @@ -150,6 +151,8 @@ /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID. struct ForallPointerDecay final { - void previsit( ObjectDecl *object ); - void previsit( FunctionDecl *func ); + void previsit( ObjectDecl * object ); + void previsit( FunctionDecl * func ); + void previsit( StructDecl * aggrDecl ); + void previsit( UnionDecl * aggrDecl ); }; @@ -265,17 +268,18 @@ HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order ReturnTypeFixer::fix( translationUnit ); // must happen before autogen + acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions acceptAll( translationUnit, genericParams ); // check as early as possible - can't happen before LinkReferenceToTypes - acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors + ReturnChecker::checkFunctionReturns( translationUnit ); + InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen Concurrency::applyKeywords( translationUnit ); + acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay Concurrency::implementMutexFuncs( translationUnit ); Concurrency::implementThreadStarter( translationUnit ); - ReturnChecker::checkFunctionReturns( translationUnit ); mutateAll( translationUnit, compoundliteral ); - acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); - acceptAll( translationUnit, finder ); + acceptAll( translationUnit, finder ); // xxx - remove this pass soon mutateAll( translationUnit, labelAddrFixer ); } @@ -368,8 +372,8 @@ DWTIterator begin( dwts.begin() ), end( dwts.end() ); if ( begin == end ) return; - FixFunction fixer; + PassVisitor fixer; DWTIterator i = begin; *i = (*i)->acceptMutator( fixer ); - if ( fixer.get_isVoid() ) { + if ( fixer.pass.isVoid ) { DWTIterator j = i; ++i; @@ -382,7 +386,7 @@ ++i; for ( ; i != end; ++i ) { - FixFunction fixer; + PassVisitor fixer; *i = (*i)->acceptMutator( fixer ); - if ( fixer.get_isVoid() ) { + if ( fixer.pass.isVoid ) { throw SemanticError( "invalid type void in function type ", func ); } // if @@ -579,6 +583,6 @@ /// Fix up assertions - flattens assertion lists, removing all trait instances - void forallFixer( Type * func ) { - for ( TypeDecl * type : func->get_forall() ) { + void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) { + for ( TypeDecl * type : forall ) { std::list< DeclarationWithType * > asserts; asserts.splice( asserts.end(), type->assertions ); @@ -596,8 +600,8 @@ // apply FixFunction to every assertion to check for invalid void type for ( DeclarationWithType *& assertion : type->assertions ) { - FixFunction fixer; + PassVisitor fixer; assertion = assertion->acceptMutator( fixer ); - if ( fixer.get_isVoid() ) { - throw SemanticError( "invalid type void in assertion of function ", func ); + if ( fixer.pass.isVoid ) { + throw SemanticError( "invalid type void in assertion of function ", node ); } // if } // for @@ -607,7 +611,7 @@ void ForallPointerDecay::previsit( ObjectDecl *object ) { - forallFixer( object->get_type() ); - if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) { - forallFixer( pointer->get_base() ); + forallFixer( object->type->forall, object ); + if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) { + forallFixer( pointer->base->forall, object ); } // if object->fixUniqueId(); @@ -615,6 +619,14 @@ void ForallPointerDecay::previsit( FunctionDecl *func ) { - forallFixer( func->get_type() ); + forallFixer( func->type->forall, func ); func->fixUniqueId(); + } + + void ForallPointerDecay::previsit( StructDecl * aggrDecl ) { + forallFixer( aggrDecl->parameters, aggrDecl ); + } + + void ForallPointerDecay::previsit( UnionDecl * aggrDecl ) { + forallFixer( aggrDecl->parameters, aggrDecl ); } @@ -656,5 +668,4 @@ } filter( translationUnit, isTypedef, true ); - } @@ -664,15 +675,15 @@ TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() ); if ( def != typedefNames.end() ) { - Type *ret = def->second.first->get_base()->clone(); + Type *ret = def->second.first->base->clone(); ret->get_qualifiers() |= typeInst->get_qualifiers(); // place instance parameters on the typedef'd type - if ( ! typeInst->get_parameters().empty() ) { + if ( ! typeInst->parameters.empty() ) { ReferenceToType *rtt = dynamic_cast(ret); if ( ! rtt ) { - throw SemanticError("cannot apply type parameters to base type of " + typeInst->get_name()); + throw SemanticError("Cannot apply type parameters to base type of " + typeInst->name); } rtt->get_parameters().clear(); - cloneAll( typeInst->get_parameters(), rtt->get_parameters() ); - mutateAll( rtt->get_parameters(), *visitor ); // recursively fix typedefs on parameters + cloneAll( typeInst->parameters, rtt->parameters ); + mutateAll( rtt->parameters, *visitor ); // recursively fix typedefs on parameters } // if delete typeInst; @@ -680,8 +691,22 @@ } else { TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() ); - assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->get_name().c_str() ); + assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() ); typeInst->set_baseType( base->second ); } // if return typeInst; + } + + struct VarLenChecker : WithShortCircuiting { + void previsit( FunctionType * ) { visit_children = false; } + void previsit( ArrayType * at ) { + isVarLen |= at->isVarLen; + } + bool isVarLen = false; + }; + + bool isVariableLength( Type * t ) { + PassVisitor varLenChecker; + maybeAccept( t, varLenChecker ); + return varLenChecker.pass.isVarLen; } @@ -694,5 +719,9 @@ Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base(); if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) { - throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() ); + throw SemanticError( "Cannot redefine typedef: " + tyDecl->name ); + } + // cannot redefine VLA typedefs + if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) { + throw SemanticError( "Cannot redefine typedef: " + tyDecl->name ); } } else { Index: src/SynTree/AddStmtVisitor.cc =================================================================== --- src/SynTree/AddStmtVisitor.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,93 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// AddStmtVisitor.cc -- -// -// Author : Rob Schluntz -// Created On : Wed Jun 22 12:11:17 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 4 11:23:47 2016 -// Update Count : 16 -// - -#include "AddStmtVisitor.h" - -#include "Common/SemanticError.h" // for SemanticError -#include "Declaration.h" // for Declaration -#include "Expression.h" // for Expression -#include "Statement.h" // for CompoundStmt, ForStmt, IfStmt, Sta... -#include "SynTree/Label.h" // for Label, noLabels - -void AddStmtVisitor::visitStatementList( std::list< Statement* > &statements ) { - for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( i, stmtsToAddAfter ); - } // if - (*i)->accept( *this ); - if ( ! stmtsToAdd.empty() ) { - statements.splice( i, stmtsToAdd ); - } // if - } // for - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( statements.end(), stmtsToAddAfter ); - } // if -} - -Statement * AddStmtVisitor::visitStatement( Statement *stmt ) { - maybeAccept( stmt, *this ); - if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) { - CompoundStmt *compound = new CompoundStmt( noLabels ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAdd ); - compound->get_kids().push_back( stmt ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAddAfter ); - return compound; - } else { - return stmt; - } -} - -void AddStmtVisitor::visit(CompoundStmt *compoundStmt) { - visitStatementList( compoundStmt->get_kids() ); -} - -void AddStmtVisitor::visit(IfStmt *ifStmt) { - ifStmt->set_thenPart( visitStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( visitStatement( ifStmt->get_elsePart() ) ); - maybeAccept( ifStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(WhileStmt *whileStmt) { - whileStmt->set_body( visitStatement( whileStmt->get_body() ) ); - maybeAccept( whileStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(ForStmt *forStmt) { - forStmt->set_body( visitStatement( forStmt->get_body() ) ); - acceptAll( forStmt->get_initialization(), *this ); - maybeAccept( forStmt->get_condition(), *this ); - maybeAccept( forStmt->get_increment(), *this ); -} - -void AddStmtVisitor::visit(SwitchStmt *switchStmt) { - visitStatementList( switchStmt->get_statements() ); - maybeAccept( switchStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(CaseStmt *caseStmt) { - visitStatementList( caseStmt->get_statements() ); - maybeAccept( caseStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(CatchStmt *catchStmt) { - catchStmt->set_body( visitStatement( catchStmt->get_body() ) ); - maybeAccept( catchStmt->get_decl(), *this ); -} - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SynTree/AddStmtVisitor.h =================================================================== --- src/SynTree/AddStmtVisitor.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ (revision ) @@ -1,47 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// AddStmtVisitor.h -- -// -// Author : Rob Schluntz -// Created On : Wed Jun 22 12:05:48 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:51:08 2017 -// Update Count : 9 -// - -#pragma once - -#include // for list - -#include "SynTree/SynTree.h" // for Visitor Nodes -#include "SynTree/Visitor.h" // for Visitor - -class AddStmtVisitor : public Visitor { - public: - typedef Visitor Parent; - - using Parent::visit; - virtual void visit(CompoundStmt *compoundStmt); - virtual void visit(IfStmt *ifStmt); - virtual void visit(WhileStmt *whileStmt); - virtual void visit(ForStmt *forStmt); - virtual void visit(SwitchStmt *switchStmt); - virtual void visit(CaseStmt *caseStmt); - virtual void visit(CatchStmt *catchStmt); - - protected: - void visitStatementList( std::list< Statement * > & ); - Statement * visitStatement( Statement * ); - std::list< Statement* > stmtsToAdd; - std::list< Statement* > stmtsToAddAfter; -}; - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SynTree/AddressExpr.cc =================================================================== --- src/SynTree/AddressExpr.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/AddressExpr.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -33,5 +33,5 @@ Type * addrType( Type * type ) { if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) { - return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) ); + return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) ); } else { return new PointerType( Type::Qualifiers(), type->clone() ); @@ -40,13 +40,13 @@ } -AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) { - if ( arg->has_result() ) { - if ( arg->get_result()->get_lvalue() ) { +AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) { + if ( arg->result ) { + if ( arg->result->get_lvalue() ) { // lvalue, retains all layers of reference and gains a pointer inside the references - set_result( addrType( arg->get_result() ) ); + set_result( addrType( arg->result ) ); } else { // taking address of non-lvalue -- must be a reference, loses one layer of reference - ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() ); - set_result( addrType( refType->get_base() ) ); + ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result ); + set_result( addrType( refType->base ) ); } // result of & is never an lvalue @@ -62,9 +62,9 @@ } -void AddressExpr::print( std::ostream &os, int indent ) const { +void AddressExpr::print( std::ostream &os, Indenter indent ) const { os << "Address of:" << std::endl; if ( arg ) { - os << std::string( indent+2, ' ' ); - arg->print( os, indent+2 ); + os << indent+1; + arg->print( os, indent+1 ); } // if } @@ -77,6 +77,6 @@ LabelAddressExpr::~LabelAddressExpr() {} -void LabelAddressExpr::print( std::ostream & os, int indent ) const { - os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg; +void LabelAddressExpr::print( std::ostream & os, Indenter ) const { + os << "Address of label:" << arg; } Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/AggregateDecl.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -41,38 +41,38 @@ } -void AggregateDecl::print( std::ostream &os, int indent ) const { +void AggregateDecl::print( std::ostream &os, Indenter indent ) const { using std::string; using std::endl; - os << typeString() << " " << get_name() << ":"; + os << typeString() << " " << name << ":"; if ( get_linkage() != LinkageSpec::Cforall ) { - os << " " << LinkageSpec::linkageName( get_linkage() ); + os << " " << LinkageSpec::linkageName( linkage ); } // if - os << " with body " << has_body() << endl; + os << " with body " << has_body(); if ( ! parameters.empty() ) { - os << endl << string( indent+2, ' ' ) << "with parameters" << endl; - printAll( parameters, os, indent+4 ); + os << endl << indent << "... with parameters" << endl; + printAll( parameters, os, indent+1 ); } // if if ( ! members.empty() ) { - os << endl << string( indent+2, ' ' ) << "with members" << endl; - printAll( members, os, indent+4 ); + os << endl << indent << "... with members" << endl; + printAll( members, os, indent+1 ); } // if if ( ! attributes.empty() ) { - os << endl << string( indent+2, ' ' ) << "with attributes" << endl; - printAll( attributes, os, indent+4 ); + os << endl << indent << "... with attributes" << endl; + printAll( attributes, os, indent+1 ); } // if + os << endl; } -void AggregateDecl::printShort( std::ostream &os, int indent ) const { +void AggregateDecl::printShort( std::ostream &os, Indenter indent ) const { using std::string; using std::endl; - os << typeString() << " " << get_name(); - os << string( indent+2, ' ' ) << "with body " << has_body() << endl; + os << typeString() << " " << name << " with body " << has_body() << endl; if ( ! parameters.empty() ) { - os << endl << string( indent+2, ' ' ) << "with parameters" << endl; - printAll( parameters, os, indent+4 ); + os << indent << "... with parameters" << endl; + printAll( parameters, os, indent+1 ); } // if } Index: src/SynTree/ApplicationExpr.cc =================================================================== --- src/SynTree/ApplicationExpr.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/ApplicationExpr.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -55,9 +55,9 @@ set_result( ResolvExpr::extractResultType( function ) ); - assert( has_result() ); + assert( result ); } ApplicationExpr::ApplicationExpr( const ApplicationExpr &other ) : - Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams ) { + Expression( other ), function( maybeClone( other.function ) ) { cloneAll( other.args, args ); } @@ -68,24 +68,12 @@ } -void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) { - if ( ! inferParams.empty() ) { - os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl; - for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) { - os << std::string(indent+2, ' '); - Declaration::declFromId( i->second.decl )->printShort( os, indent+2 ); - os << std::endl; - printInferParams( *i->second.inferParams, os, indent+2, level+1 ); - } // for +void ApplicationExpr::print( std::ostream &os, Indenter indent ) const { + os << "Application of" << std::endl << indent+1; + function->print( os, indent+1 ); + os << std::endl; + if ( ! args.empty() ) { + os << indent << "... to arguments" << std::endl; + printAll( args, os, indent+1 ); } // if -} - -void ApplicationExpr::print( std::ostream &os, int indent ) const { - os << "Application of" << std::endl << std::string(indent+2, ' '); - function->print( os, indent+2 ); - if ( ! args.empty() ) { - os << std::string( indent, ' ' ) << "to arguments" << std::endl; - printAll( args, os, indent+2 ); - } // if - printInferParams( inferParams, os, indent+2, 0 ); Expression::print( os, indent ); } Index: src/SynTree/ArrayType.cc =================================================================== --- src/SynTree/ArrayType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/ArrayType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -39,5 +39,5 @@ } -void ArrayType::print( std::ostream &os, int indent ) const { +void ArrayType::print( std::ostream &os, Indenter indent ) const { Type::print( os, indent ); if ( isStatic ) { Index: src/SynTree/AttrType.cc =================================================================== --- src/SynTree/AttrType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/AttrType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// AttrType.cc.cc -- +// AttrType.cc.cc -- // // Author : Richard C. Bilson @@ -42,5 +42,5 @@ } -void AttrType::print( std::ostream &os, int indent ) const { +void AttrType::print( std::ostream &os, Indenter indent ) const { Type::print( os, indent ); os << "attribute " << name << " applied to "; Index: src/SynTree/Attribute.cc =================================================================== --- src/SynTree/Attribute.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/Attribute.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -28,5 +28,5 @@ } -void Attribute::print( std::ostream &os, int indent ) const { +void Attribute::print( std::ostream &os, Indenter indent ) const { using std::endl; using std::string; @@ -36,5 +36,5 @@ if ( ! parameters.empty() ) { os << " with parameters: " << endl; - printAll( parameters, os, indent ); + printAll( parameters, os, indent+1 ); } } Index: src/SynTree/Attribute.h =================================================================== --- src/SynTree/Attribute.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/Attribute.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -20,10 +20,18 @@ #include // for string, operator== +#include "BaseSyntaxNode.h" +#include "Mutator.h" +#include "Visitor.h" + class Expression; // GCC attribute // https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Attribute-Syntax.html#Attribute-Syntax -class Attribute { +class Attribute : public BaseSyntaxNode { public: + std::string name; + // to keep things nice and tight, use NameExpr for special identifier parameters + std::list< Expression * > parameters; + Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {} Attribute( const Attribute &other ); @@ -35,10 +43,8 @@ bool empty() const { return name == ""; } - Attribute * clone() const { return new Attribute( *this ); } - void print( std:: ostream &os, int indent = 0 ) const; - private: - std::string name; - // to keep things nice and tight, use NameExpr for special identifier parameters - std::list< Expression * > parameters; + Attribute * clone() const override { return new Attribute( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; Index: src/SynTree/BaseSyntaxNode.h =================================================================== --- src/SynTree/BaseSyntaxNode.h (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/BaseSyntaxNode.h (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -17,5 +17,7 @@ #include "Common/CodeLocation.h" +#include "Common/Indenter.h" class Visitor; +class Mutator; class BaseSyntaxNode { @@ -25,7 +27,17 @@ virtual ~BaseSyntaxNode() {} + virtual BaseSyntaxNode * clone() const = 0; virtual void accept( Visitor & v ) = 0; - virtual void print( std::ostream & os, int indent = 0 ) const = 0; + virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0; + /// Notes: + /// * each node is responsible for indenting its children. + /// * Expressions should not finish with a newline, since the expression's parent has better information. + virtual void print( std::ostream & os, Indenter indent = {} ) const = 0; + void print( std::ostream & os, unsigned int indent ) { + print( os, Indenter{ Indenter::tabsize, indent }); + } }; + +std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ); // Local Variables: // Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/BasicType.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// BasicType.cc -- +// BasicType.cc -- // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 11 12:52:05 2017 -// Update Count : 9 +// Last Modified On : Mon Sep 25 14:14:03 2017 +// Update Count : 11 // @@ -24,5 +24,5 @@ BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {} -void BasicType::print( std::ostream &os, int indent ) const { +void BasicType::print( std::ostream &os, Indenter indent ) const { Type::print( os, indent ); os << BasicType::typeNames[ kind ]; @@ -43,4 +43,6 @@ case LongLongSignedInt: case LongLongUnsignedInt: + case SignedInt128: + case UnsignedInt128: return true; case Float: Index: src/SynTree/CommaExpr.cc =================================================================== --- src/SynTree/CommaExpr.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/CommaExpr.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -21,6 +21,6 @@ #include "Type.h" // for Type -CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname ) - : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) { +CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 ) + : Expression(), arg1( arg1 ), arg2( arg2 ) { // xxx - result of a comma expression is never an lvalue, so should set lvalue // to false on all result types. Actually doing this causes some strange things @@ -39,11 +39,11 @@ } -void CommaExpr::print( std::ostream &os, int indent ) const { +void CommaExpr::print( std::ostream &os, Indenter indent ) const { os << "Comma Expression:" << std::endl; - os << std::string( indent+2, ' ' ); - arg1->print( os, indent+2 ); + os << (indent+1); + arg1->print( os, indent+1 ); os << std::endl; - os << std::string( indent+2, ' ' ); - arg2->print( os, indent+2 ); + os << (indent+1); + arg2->print( os, indent+1 ); Expression::print( os, indent ); } Index: src/SynTree/CompoundStmt.cc =================================================================== --- src/SynTree/CompoundStmt.cc (revision 783152722192169260028e02eebed9a9a0c374a7) +++ src/SynTree/CompoundStmt.cc (revision 3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a) @@ -29,4 +29,7 @@ CompoundStmt::CompoundStmt( std::list