Changeset 3253c32

Timestamp:

Jun 24, 2019, 1:26:04 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

fb2bde4

Parents:

397edf7 (diff), b58affe7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• Jenkinsfile (modified) (1 diff)
• driver/cc1.cc (modified) (3 diffs)
• src/AST/Convert.cpp (modified) (1 diff)
• src/AST/Node.hpp (modified) (2 diffs)
• src/ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• src/ResolvExpr/Resolver.cc (modified) (2 diffs)
• src/ResolvExpr/Resolver.h (modified) (2 diffs)
• src/SymTab/Validate.cc (modified) (4 diffs)
• src/SymTab/Validate.h (modified) (2 diffs)
• tests/sum.cfa (modified) (2 diffs)

Jenkinsfile

@@ -130 +130 @@
                         //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 {

driver/cc1.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// cc1.cc -- 
+// cc1.cc --
 //
 // Author           : Peter A. Buhr
@@ -107 +107 @@
         if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
                 rmtmpfile();                                                                    // remove
-                exit( EXIT_FAILURE );                                                   // terminate 
+                exit( EXIT_FAILURE );                                                   // terminate
         } // if
 } // sigTermHandler
@@ -360 +360 @@
 
                 #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] << " ";

src/AST/Convert.cpp

@@ -1895 +1895 @@
                 };
                 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),
                 };
 

src/AST/Node.hpp

@@ -100 +100 @@
 
 /// Mutate a node field (only clones if not equal to existing value)
-template<typename node_t, typename field_t, typename assn_t>
-const node_t * mutate_field( const node_t * node, field_t node_t::* field, assn_t && val ) {
+template<typename node_t, typename parent_t, typename field_t, typename assn_t>
+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 +112 @@
 
 /// Mutate a single index of a node field (only clones if not equal to existing value)
-template<typename node_t, typename coll_t, typename ind_t, typename field_t>
+template<typename node_t, typename parent_t, typename coll_t, typename ind_t, typename field_t>
 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

src/ResolvExpr/CandidateFinder.cpp

@@ -1003 +1003 @@
                         assert( toType );
                         toType = resolveTypeof( toType, symtab );
-                        toType = SymTab::validateType( toType, symtab );
+                        toType = SymTab::validateType( castExpr->location, toType, symtab );
                         toType = adjustExprType( toType, tenv, symtab );
 
@@ -1410 +1410 @@
                                 // 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 

src/ResolvExpr/Resolver.cc

@@ -1154 +1154 @@
                         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 +1166 @@
                 }
 
+        namespace {
                 /// Predicate for "Candidate has integral type"
                 bool hasIntegralType( const Candidate & i ) {

src/ResolvExpr/Resolver.h

@@ -35 +35 @@
         class StmtExpr;
         class SymbolTable;
+        class Type;
         class TypeEnvironment;
 } // namespace ast
@@ -61 +62 @@
         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( 

src/SymTab/Validate.cc

@@ -44 +44 @@
 #include <list>                        // for list
 #include <string>                      // for string
+#include <unordered_map>               // for unordered_map
 #include <utility>                     // for pair
 
+#include "AST/Chain.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Node.hpp"
@@ -54 +56 @@
 #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 +1431 @@
 
         /// 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<LinkReferenceToTypes_new>, 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 +1709 @@
 } // 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;
 

src/SymTab/Validate.h

@@ -19 +19 @@
 #include <list>  // for list
 
+class CodeLocation;
 class Declaration;
 class Type;
@@ -34 +35 @@
         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
 

tests/sum.cfa

@@ -35 +35 @@
 
 int main( void ) {
+#if 0
         const int low = 5, High = 15, size = High - low;
 
@@ -121 +122 @@
                  | 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