Index: Jenkinsfile =================================================================== --- Jenkinsfile (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ Jenkinsfile (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -130,6 +130,6 @@ //Run the tests from the tests directory if ( Settings.RunAllTests ) { - sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=yes' - sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=no ' + sh 'make --no-print-directory -C tests timeouts="--timeout=1200" all-tests debug=yes' + sh 'make --no-print-directory -C tests timeouts="--timeout=1200" all-tests debug=no ' } else { Index: driver/cc1.cc =================================================================== --- driver/cc1.cc (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ driver/cc1.cc (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// cc1.cc -- +// cc1.cc -- // // Author : Peter A. Buhr @@ -107,5 +107,5 @@ if ( tmpfilefd != -1 ) { // RACE, file created ? rmtmpfile(); // remove - exit( EXIT_FAILURE ); // terminate + exit( EXIT_FAILURE ); // terminate } // if } // sigTermHandler @@ -360,5 +360,5 @@ #ifdef __DEBUG_H__ - cerr << "cfa-cpp ncargs: " << o_name << " " << CFA_flag << " " << ncargs << endl; + cerr << "cfa-cpp ncargs: " << (o_name ? o_name : "No -o") << " " << CFA_flag << " " << ncargs << endl; for ( int i = 0; cargs[i] != NULL; i += 1 ) { cerr << cargs[i] << " "; Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/AST/Convert.cpp (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -1895,6 +1895,6 @@ }; stmt->orElse = { - GET_ACCEPT_1(timeout.statement, Stmt), - GET_ACCEPT_1(timeout.condition, Expr), + GET_ACCEPT_1(orelse.statement, Stmt), + GET_ACCEPT_1(orelse.condition, Expr), }; Index: src/AST/Node.hpp =================================================================== --- src/AST/Node.hpp (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/AST/Node.hpp (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -100,6 +100,6 @@ /// Mutate a node field (only clones if not equal to existing value) -template -const node_t * mutate_field( const node_t * node, field_t node_t::* field, assn_t && val ) { +template +const node_t * mutate_field( const node_t * node, field_t parent_t::* field, assn_t && val ) { // skip mutate if equivalent if ( node->*field == val ) return node; @@ -112,7 +112,7 @@ /// Mutate a single index of a node field (only clones if not equal to existing value) -template +template const node_t * mutate_field_index( - const node_t * node, coll_t node_t::* field, ind_t i, field_t && val + const node_t * node, coll_t parent_t::* field, ind_t i, field_t && val ) { // skip mutate if equivalent Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/ResolvExpr/CandidateFinder.cpp (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -1003,5 +1003,5 @@ assert( toType ); toType = resolveTypeof( toType, symtab ); - toType = SymTab::validateType( toType, symtab ); + toType = SymTab::validateType( castExpr->location, toType, symtab ); toType = adjustExprType( toType, tenv, symtab ); @@ -1410,5 +1410,5 @@ // calculate target type const ast::Type * toType = resolveTypeof( initAlt.type, symtab ); - toType = SymTab::validateType( toType, symtab ); + toType = SymTab::validateType( initExpr->location, toType, symtab ); toType = adjustExprType( toType, tenv, symtab ); // The call to find must occur inside this loop, otherwise polymorphic return Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/ResolvExpr/Resolver.cc (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -1154,7 +1154,6 @@ return findKindExpression( untyped, symtab ); } - - /// Resolve `untyped` to the single expression whose candidate is the best match for the - /// given type. + } // anonymous namespace + ast::ptr< ast::Expr > findSingleExpression( const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab @@ -1167,4 +1166,5 @@ } + namespace { /// Predicate for "Candidate has integral type" bool hasIntegralType( const Candidate & i ) { Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/ResolvExpr/Resolver.h (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -35,4 +35,5 @@ class StmtExpr; class SymbolTable; + class Type; class TypeEnvironment; } // namespace ast @@ -61,4 +62,8 @@ ast::ptr< ast::Expr > resolveInVoidContext( const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env ); + /// Resolve `untyped` to the single expression whose candidate is the best match for the + /// given type. + ast::ptr< ast::Expr > findSingleExpression( + const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab ); /// Resolves a constructor init expression ast::ptr< ast::Init > resolveCtorInit( Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/SymTab/Validate.cc (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -44,6 +44,8 @@ #include // for list #include // for string +#include // for unordered_map #include // for pair +#include "AST/Chain.hpp" #include "AST/Decl.hpp" #include "AST/Node.hpp" @@ -54,4 +56,5 @@ #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign #include "ControlStruct/Mutate.h" // for ForExprMutator +#include "Common/CodeLocation.h" // for CodeLocation #include "Common/Stats.h" // for Stats::Heap #include "Common/PassVisitor.h" // for PassVisitor, WithDeclsToAdd @@ -1428,13 +1431,273 @@ /// Associates forward declarations of aggregates with their definitions - struct LinkReferenceToTypes_new final + class LinkReferenceToTypes_new final : public ast::WithSymbolTable, public ast::WithGuards, public ast::WithVisitorRef, public ast::WithShortCircuiting { - const ast::SymbolTable * localSyms; - - LinkReferenceToTypes_new( const ast::SymbolTable & syms ) : localSyms( &syms ) {} - - #warning incomplete + // these maps of uses of forward declarations of types need to have the actual type + // declaration switched in *after* they have been traversed. To enable this in the + // ast::Pass framework, any node that needs to be so mutated has mutate() called on it + // before it is placed in the map, properly updating its parents in the usual traversal, + // then can have the actual mutation applied later + using ForwardEnumsType = std::unordered_multimap< std::string, ast::EnumInstType * >; + using ForwardStructsType = std::unordered_multimap< std::string, ast::StructInstType * >; + using ForwardUnionsType = std::unordered_multimap< std::string, ast::UnionInstType * >; + + const CodeLocation & location; + const ast::SymbolTable * localSymtab; + + ForwardEnumsType forwardEnums; + ForwardStructsType forwardStructs; + ForwardUnionsType forwardUnions; + + /// true if currently in a generic type body, so that type parameter instances can be + /// renamed appropriately + bool inGeneric = false; + + public: + /// contstruct using running symbol table + LinkReferenceToTypes_new( const CodeLocation & loc ) + : location( loc ), localSymtab( &symtab ) {} + + /// construct using provided symbol table + LinkReferenceToTypes_new( const CodeLocation & loc, const ast::SymbolTable & syms ) + : location( loc ), localSymtab( &syms ) {} + + const ast::Type * postvisit( const ast::TypeInstType * typeInst ) { + // ensure generic parameter instances are renamed like the base type + if ( inGeneric && typeInst->base ) { + typeInst = ast::mutate_field( + typeInst, &ast::TypeInstType::name, typeInst->base->name ); + } + + if ( + auto typeDecl = dynamic_cast< const ast::TypeDecl * >( + localSymtab->lookupType( typeInst->name ) ) + ) { + typeInst = ast::mutate_field( typeInst, &ast::TypeInstType::kind, typeDecl->kind ); + } + + return typeInst; + } + + const ast::Type * postvisit( const ast::EnumInstType * inst ) { + const ast::EnumDecl * decl = localSymtab->lookupEnum( inst->name ); + // not a semantic error if the enum is not found, just an implicit forward declaration + if ( decl ) { + inst = ast::mutate_field( inst, &ast::EnumInstType::base, decl ); + } + if ( ! decl || ! decl->body ) { + // forward declaration + auto mut = mutate( inst ); + forwardEnums.emplace( inst->name, mut ); + inst = mut; + } + return inst; + } + + void checkGenericParameters( const ast::ReferenceToType * inst ) { + for ( const ast::Expr * param : inst->params ) { + if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) { + SemanticError( + location, inst, "Expression parameters for generic types are currently " + "unsupported: " ); + } + } + } + + const ast::StructInstType * postvisit( const ast::StructInstType * inst ) { + const ast::StructDecl * decl = localSymtab->lookupStruct( inst->name ); + // not a semantic error if the struct is not found, just an implicit forward declaration + if ( decl ) { + inst = ast::mutate_field( inst, &ast::StructInstType::base, decl ); + } + if ( ! decl || ! decl->body ) { + // forward declaration + auto mut = mutate( inst ); + forwardStructs.emplace( inst->name, mut ); + inst = mut; + } + checkGenericParameters( inst ); + return inst; + } + + const ast::UnionInstType * postvisit( const ast::UnionInstType * inst ) { + const ast::UnionDecl * decl = localSymtab->lookupUnion( inst->name ); + // not a semantic error if the struct is not found, just an implicit forward declaration + if ( decl ) { + inst = ast::mutate_field( inst, &ast::UnionInstType::base, decl ); + } + if ( ! decl || ! decl->body ) { + // forward declaration + auto mut = mutate( inst ); + forwardUnions.emplace( inst->name, mut ); + inst = mut; + } + checkGenericParameters( inst ); + return inst; + } + + const ast::Type * postvisit( const ast::TraitInstType * traitInst ) { + // handle other traits + const ast::TraitDecl * traitDecl = localSymtab->lookupTrait( traitInst->name ); + if ( ! traitDecl ) { + SemanticError( location, "use of undeclared trait " + traitInst->name ); + } + if ( traitDecl->params.size() != traitInst->params.size() ) { + SemanticError( location, traitInst, "incorrect number of trait parameters: " ); + } + traitInst = ast::mutate_field( traitInst, &ast::TraitInstType::base, traitDecl ); + + // need to carry over the "sized" status of each decl in the instance + for ( unsigned i = 0; i < traitDecl->params.size(); ++i ) { + auto expr = traitInst->params[i].as< ast::TypeExpr >(); + if ( ! expr ) { + SemanticError( + traitInst->params[i].get(), "Expression parameters for trait instances " + "are currently unsupported: " ); + } + + if ( auto inst = expr->type.as< ast::TypeInstType >() ) { + if ( traitDecl->params[i]->sized && ! inst->base->sized ) { + // traitInst = ast::mutate_field_index( + // traitInst, &ast::TraitInstType::params, i, + // ... + // ); + ast::TraitInstType * mut = ast::mutate( traitInst ); + ast::chain_mutate( mut->params[i] ) + ( &ast::TypeExpr::type ) + ( &ast::TypeInstType::base )->sized = true; + traitInst = mut; + } + } + } + + return traitInst; + } + + void previsit( const ast::QualifiedType * ) { visit_children = false; } + + const ast::Type * postvisit( const ast::QualifiedType * qualType ) { + // linking only makes sense for the "oldest ancestor" of the qualified type + return ast::mutate_field( + qualType, &ast::QualifiedType::parent, qualType->parent->accept( *visitor ) ); + } + + const ast::Decl * postvisit( const ast::EnumDecl * enumDecl ) { + // visit enum members first so that the types of self-referencing members are updated + // properly + if ( ! enumDecl->body ) return enumDecl; + + // update forward declarations to point here + auto fwds = forwardEnums.equal_range( enumDecl->name ); + if ( fwds.first != fwds.second ) { + auto inst = fwds.first; + do { + // forward decl is stored *mutably* in map, can thus be updated + inst->second->base = enumDecl; + } while ( ++inst != fwds.second ); + forwardEnums.erase( fwds.first, fwds.second ); + } + + // ensure that enumerator initializers are properly set + for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) { + auto field = enumDecl->members[i].strict_as< ast::ObjectDecl >(); + if ( field->init ) { + // need to resolve enumerator initializers early so that other passes that + // determine if an expression is constexpr have appropriate information + auto init = field->init.strict_as< ast::SingleInit >(); + + enumDecl = ast::mutate_field_index( + enumDecl, &ast::EnumDecl::members, i, + ast::mutate_field( field, &ast::ObjectDecl::init, + ast::mutate_field( init, &ast::SingleInit::value, + ResolvExpr::findSingleExpression( + init->value, new ast::BasicType{ ast::BasicType::SignedInt }, + symtab ) ) ) ); + } + } + + return enumDecl; + } + + /// rename generic type parameters uniquely so that they do not conflict with user defined + /// function forall parameters, e.g. the T in Box and the T in f, below + /// forall(otype T) + /// struct Box { + /// T x; + /// }; + /// forall(otype T) + /// void f(Box(T) b) { + /// ... + /// } + template< typename AggrDecl > + const AggrDecl * renameGenericParams( const AggrDecl * aggr ) { + GuardValue( inGeneric ); + inGeneric = ! aggr->params.empty(); + + for ( unsigned i = 0; i < aggr->params.size(); ++i ) { + const ast::TypeDecl * td = aggr->params[i]; + + aggr = ast::mutate_field_index( + aggr, &AggrDecl::params, i, + ast::mutate_field( td, &ast::TypeDecl::name, "__" + td->name + "_generic_" ) ); + } + return aggr; + } + + const ast::StructDecl * previsit( const ast::StructDecl * structDecl ) { + return renameGenericParams( structDecl ); + } + + void postvisit( const ast::StructDecl * structDecl ) { + // visit struct members first so that the types of self-referencing members are + // updated properly + if ( ! structDecl->body ) return; + + // update forward declarations to point here + auto fwds = forwardStructs.equal_range( structDecl->name ); + if ( fwds.first != fwds.second ) { + auto inst = fwds.first; + do { + // forward decl is stored *mutably* in map, can thus be updated + inst->second->base = structDecl; + } while ( ++inst != fwds.second ); + forwardStructs.erase( fwds.first, fwds.second ); + } + } + + const ast::UnionDecl * previsit( const ast::UnionDecl * unionDecl ) { + return renameGenericParams( unionDecl ); + } + + void postvisit( const ast::UnionDecl * unionDecl ) { + // visit union members first so that the types of self-referencing members are updated + // properly + if ( ! unionDecl->body ) return; + + // update forward declarations to point here + auto fwds = forwardUnions.equal_range( unionDecl->name ); + if ( fwds.first != fwds.second ) { + auto inst = fwds.first; + do { + // forward decl is stored *mutably* in map, can thus be updated + inst->second->base = unionDecl; + } while ( ++inst != fwds.second ); + forwardUnions.erase( fwds.first, fwds.second ); + } + } + + const ast::Decl * postvisit( const ast::TraitDecl * traitDecl ) { + // set the "sized" status for the special "sized" trait + if ( traitDecl->name != "sized" ) return traitDecl; + + assertf( traitDecl->params.size() == 1, "Built-in trait 'sized' has incorrect number " + "of parameters: %zd", traitDecl->params.size() ); + + return ast::mutate_field_index( + traitDecl, &ast::TraitDecl::params, 0, + ast::mutate_field( + traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) ); + } }; @@ -1446,7 +1709,8 @@ } // anonymous namespace -const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab ) { +const ast::Type * validateType( + const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) { ast::Pass< EnumAndPointerDecay_new > epc; - ast::Pass< LinkReferenceToTypes_new > lrt{ symtab }; + ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab }; ast::Pass< ForallPointerDecay_new > fpd; Index: src/SymTab/Validate.h =================================================================== --- src/SymTab/Validate.h (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ src/SymTab/Validate.h (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -19,4 +19,5 @@ #include // for list +class CodeLocation; class Declaration; class Type; @@ -34,5 +35,6 @@ void validateType( Type *type, const Indexer *indexer ); - const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab ); + const ast::Type * validateType( + const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ); } // namespace SymTab Index: tests/sum.cfa =================================================================== --- tests/sum.cfa (revision 397edf7a638bd273ce80fb1fb107f1eaabf93eec) +++ tests/sum.cfa (revision 3253c329c0ac72e5ef5bb4a2e363de4c77d135cb) @@ -35,4 +35,5 @@ int main( void ) { +#if 0 const int low = 5, High = 15, size = High - low; @@ -121,4 +122,92 @@ | sum( size, gs.x ) | ", check" | (int)s; // add field array in generic type delete( gs.x ); +#else + const int low = 5, High = 15, size = High - low; + + signed char s = 0, a[size], v = (char)low; + for ( int i = 0; i < size; i += 1, v += 1hh ) { + s += v; + a[i] = v; + } // for + printf( "sum from %d to %d is %hhd, check %hhd\n", low, High, + sum( size, (signed char *)a ), (signed char)s ); + + unsigned char s = 0, a[size], v = low; + for ( int i = 0; i < size; i += 1, v += 1hhu ) { + s += (unsigned char)v; + a[i] = (unsigned char)v; + } // for + printf( "sum from %d to %d is %hhu, check %hhu\n", low, High, + sum( size, (unsigned char *)a ), (unsigned char)s ); + + short int s = 0, a[size], v = low; + for ( int i = 0; i < size; i += 1, v += 1h ) { + s += (short int)v; + a[i] = (short int)v; + } // for + printf( "sum from %d to %d is %hd, check %hd\n", low, High, + sum( size, (short int *)a ), (short int)s ); + + int s = 0, a[size], v = low; + for ( int i = 0; i < size; i += 1, v += 1 ) { + s += (int)v; + a[i] = (int)v; + } // for + printf( "sum from %d to %d is %d, check %d\n", low, High, + sum( size, (int *)a ), (int)s ); + + float s = 0.0f, a[size], v = low / 10.0f; + for ( int i = 0; i < size; i += 1, v += 0.1f ) { + s += (float)v; + a[i] = (float)v; + } // for + printf( "sum from %g to %g is %g, check %g\n", low / 10.0f, High / 10.0f, + sum( size, (float *)a ), (float)s ); + + double s = 0.0, a[size], v = low / 10.0; + for ( int i = 0; i < size; i += 1, v += 0.1 ) { + s += (double)v; + a[i] = (double)v; + } // for + printf( "sum from %g to %g is %g, check %g\n", low / 10.0f, High / 10.0f, + sum( size, (double *)a ), (double)s ); + + struct S { int i, j; }; + void ?{}( S & s ) { s.[i, j] = 0; } + void ?{}( S & s, int i ) { s.[i, j] = [i, 0]; } + void ?{}( S & s, int i, int j ) { s.[i, j] = [i, j]; } + void ?{}( S & s, zero_t ) { s.[i, j] = 0; } + void ?{}( S & s, one_t ) { s.[i, j] = 1; } + S ?+?( S t1, S t2 ) { return (S){ t1.i + t2.i, t1.j + t2.j }; } + S ?+=?( S & t1, S t2 ) { t1 = t1 + t2; return t1; } + S ++?( S & t ) { t += (S){1}; return t; } + S ?++( S & t ) { S temp = t; t += (S){1}; return temp; } + ofstream & ?|?( ofstream & os, S v ) { return os | v.i | v.j; } + void ?|?( ofstream & os, S v ) { (ofstream &)(os | v); nl( os ); } + + S s = (S){0}, a[size], v = { low, low }; + for ( int i = 0; i < size; i += 1, v += (S){1} ) { + s += (S)v; + a[i] = (S)v; + } // for + printf( "sum from %d to %d is %d %d, check %d %d\n", low, High, + sum( size, (S *)a ).[i, j], s.[i, j] ); + + forall( otype Impl | sumable( Impl ) ) + struct GS { + Impl * x, * y; + }; + GS(int) gs; + // FIX ME, resolution problem with anew not picking up the LH type + gs.x = (typeof(gs.x))anew( size ); // create array storage for field + s = 0; v = low; + for ( int i = 0; i < size; i += 1, v += 1 ) { + s += (int)v; + gs.x[i] = (int)v; // set field array in generic type + } // for + printf( "sum from %d to %d is %d, check %d\n", low, High, + sum( size, gs.x ), (int)s ); // add field array in generic type + delete( gs.x ); +#endif } // main