Changeset 1ed9cb63 for src

Timestamp:

Oct 27, 2021, 5:15:41 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

40a64f78

Parents:

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

Message:

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

Location:

src

Files:

• AST/Pass.hpp (modified) (2 diffs)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Pass.proto.hpp (modified) (1 diff)
• AST/TranslationUnit.hpp (modified) (1 diff)
• AST/porting.md (modified) (1 diff)
• CodeTools/DeclStats.cc (modified) (3 diffs)
• Common/DeclStats.cpp (added)
• Common/DeclStats.hpp (added)
• Common/ResolvProtoDump.cpp (added)
• Common/ResolvProtoDump.hpp (added)
• Common/module.mk (modified) (2 diffs)
• InitTweak/GenInit.cc (modified) (3 diffs)
• InitTweak/GenInit.h (modified) (2 diffs)
• Parser/parser.yy (modified) (14 diffs)
• main.cc (modified) (5 diffs)

src/AST/Pass.hpp

@@ -348 +348 @@
 
         /// When this node is finished being visited, restore the value of a variable
+        /// You may assign to the return value to set the new value in the same statement.
         template< typename T >
-        void GuardValue( T& val ) {
+        T& GuardValue( T& val ) {
                 at_cleanup( [ val ]( void * newVal ) {
                         * static_cast< T * >( newVal ) = val;
                 }, static_cast< void * >( & val ) );
+                return val;
         }
 
@@ -394 +396 @@
 };
 
+/// Used to get a pointer to the wrapping TranslationUnit.
+struct WithConstTranslationUnit {
+        const TranslationUnit * translationUnit = nullptr;
+
+        const TranslationUnit & transUnit() const {
+                assertf( translationUnit, "WithConstTranslationUnit not set-up." );
+                return *translationUnit;
+        }
+};
+
 }
 

src/AST/Pass.impl.hpp

@@ -420 +420 @@
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
-        return ast::accept_all( unit.decls, visitor );
+        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
+                ValueGuard<const TranslationUnit *> guard( *ptr );
+                *ptr = &unit;
+                return ast::accept_all( unit.decls, visitor );
+        } else {
+                return ast::accept_all( unit.decls, visitor );
+        }
 }
 

src/AST/Pass.proto.hpp

@@ -426 +426 @@
         } // namespace forall
 
+        // For passes that need access to the global context. Sreaches `translationUnit`
+        namespace translation_unit {
+                template<typename core_t>
+                static inline auto get_cptr( core_t & core, int )
+                                -> decltype( &core.translationUnit ) {
+                        return &core.translationUnit;
+                }
+
+                template<typename core_t>
+                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                        return nullptr;
+                }
+        }
+
         template<typename core_t>
         static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {

src/AST/TranslationUnit.hpp

@@ -26 +26 @@
         std::list< ptr< Decl > > decls;
 
-        struct Globals {
+        struct Global {
                 std::map< UniqueId, Decl * > idMap;
 
-                const Type * sizeType;
+                ptr<Type> sizeType;
                 const FunctionDecl * dereference;
                 const StructDecl * dtorStruct;

src/AST/porting.md

@@ -98 +98 @@
         * `Initializer` => `ast::Init`
     * `Statement` => `ast::Stmt`
+    * `ReferenceToType` => `ast::BaseInstType`
         * any field names should follow a similar renaming
   * because they don't really belong to `Type` (and for consistency with `Linkage::Spec`):

src/CodeTools/DeclStats.cc

@@ -156 +156 @@
                 /// number of counting bins for linkages
                 static const unsigned n_named_specs = 8;
-                /// map from total number of specs to bins
-                static const unsigned ind_for_linkage[16];
+                /// Mapping function from linkage to bin.
+                static unsigned linkage_index( LinkageSpec::Spec spec ) {
+                        switch ( spec ) {
+                        case LinkageSpec::Intrinsic:  return 0;
+                        case LinkageSpec::C:          return 1;
+                        case LinkageSpec::Cforall:    return 2;
+                        case LinkageSpec::AutoGen:    return 3;
+                        case LinkageSpec::Compiler:   return 4;
+                        case LinkageSpec::BuiltinCFA: return 5;
+                        case LinkageSpec::BuiltinC:   return 6;
+                        default:                      return 7;
+                        }
+                }
 
                 Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
@@ -366 +377 @@
                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
                         if ( seen_names.insert( mangleName ).second ) {
-                                Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
+                                Stats& stats = for_linkage[ linkage_index( decl->linkage ) ];
 
                                 ++stats.n_decls;
@@ -527 +538 @@
         };
 
-        const unsigned DeclStats::ind_for_linkage[]
-                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
-
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<DeclStats> stats;

src/Common/module.mk

@@ -22 +22 @@
       Common/CompilerError.h \
       Common/Debug.h \
+      Common/DeclStats.hpp \
+      Common/DeclStats.cpp \
       Common/ErrorObjects.h \
       Common/Eval.cc \
@@ -33 +35 @@
       Common/PassVisitor.proto.h \
       Common/PersistentMap.h \
+      Common/ResolvProtoDump.hpp \
+      Common/ResolvProtoDump.cpp \
       Common/ScopedMap.h \
       Common/SemanticError.cc \

src/InitTweak/GenInit.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:15:10 2019
-// Update Count     : 184
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Oct 25 13:53:00 2021
+// Update Count     : 186
 //
 #include "GenInit.h"
@@ -24 +24 @@
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
@@ -294 +295 @@
         }
 
+namespace {
+
+#       warning Remove the _New suffix after the conversion is complete.
+        struct HoistArrayDimension_NoResolve_New final :
+                        public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting,
+                        public ast::WithGuards, public ast::WithConstTranslationUnit,
+                        public ast::WithVisitorRef<HoistArrayDimension_NoResolve_New> {
+                void previsit( const ast::ObjectDecl * decl );
+                const ast::DeclWithType * postvisit( const ast::ObjectDecl * decl );
+                // Do not look for objects inside there declarations (and type).
+                void previsit( const ast::AggregateDecl * ) { visit_children = false; }
+                void previsit( const ast::NamedTypeDecl * ) { visit_children = false; }
+                void previsit( const ast::FunctionType * ) { visit_children = false; }
+
+                const ast::Type * hoist( const ast::Type * type );
+
+                ast::Storage::Classes storageClasses;
+        };
+
+        void HoistArrayDimension_NoResolve_New::previsit(
+                        const ast::ObjectDecl * decl ) {
+                GuardValue( storageClasses ) = decl->storage;
+        }
+
+        const ast::DeclWithType * HoistArrayDimension_NoResolve_New::postvisit(
+                        const ast::ObjectDecl * objectDecl ) {
+                return mutate_field( objectDecl, &ast::ObjectDecl::type,
+                                hoist( objectDecl->type ) );
+        }
+
+        const ast::Type * HoistArrayDimension_NoResolve_New::hoist(
+                        const ast::Type * type ) {
+                static UniqueName dimensionName( "_array_dim" );
+
+                if ( !isInFunction() || storageClasses.is_static ) {
+                        return type;
+                }
+
+                if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        if ( nullptr == arrayType->dimension ) {
+                                return type;
+                        }
+
+                        if ( !Tuples::maybeImpure( arrayType->dimension ) ) {
+                                return type;
+                        }
+
+                        ast::ptr<ast::Type> dimType = transUnit().global.sizeType;
+                        assert( dimType );
+                        add_qualifiers( dimType, ast::CV::Qualifiers( ast::CV::Const ) );
+
+                        ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
+                                arrayType->dimension->location,
+                                dimensionName.newName(),
+                                dimType,
+                                new ast::SingleInit(
+                                        arrayType->dimension->location,
+                                        arrayType->dimension
+                                )
+                        );
+
+                        ast::ArrayType * mutType = ast::mutate( arrayType );
+                        mutType->dimension = new ast::VariableExpr(
+                                        arrayDimension->location, arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
+
+                        mutType->base = hoist( mutType->base );
+                        return mutType;
+                }
+                return type;
+        }
+
+        struct ReturnFixer_New final :
+                        public ast::WithStmtsToAdd<>, ast::WithGuards {
+                void previsit( const ast::FunctionDecl * decl );
+                const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
+        private:
+                const ast::FunctionDecl * funcDecl = nullptr;
+        };
+
+        void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
+                GuardValue( funcDecl ) = decl;
+        }
+
+        const ast::ReturnStmt * ReturnFixer_New::previsit(
+                        const ast::ReturnStmt * stmt ) {
+                auto & returns = funcDecl->returns;
+                assert( returns.size() < 2 );
+                // Hands off if the function returns a reference.
+                // Don't allocate a temporary if the address is returned.
+                if ( stmt->expr && 1 == returns.size() ) {
+                        ast::ptr<ast::DeclWithType> retDecl = returns.front();
+                        if ( isConstructable( retDecl->get_type() ) ) {
+                                // Explicitly construct the return value using the return
+                                // expression and the retVal object.
+                                assertf( "" != retDecl->name,
+                                        "Function %s has unnamed return value.\n",
+                                        funcDecl->name.c_str() );
+
+                                auto retVal = retDecl.strict_as<ast::ObjectDecl>();
+                                if ( auto varExpr = stmt->expr.as<ast::VariableExpr>() ) {
+                                        // Check if the return statement is already set up.
+                                        if ( varExpr->var == retVal ) return stmt;
+                                }
+                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
+                                        retVal->location, "?{}", retVal, stmt->expr );
+                                assertf( ctorStmt,
+                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
+                                        toString( retVal ).c_str(),
+                                        toString( stmt->expr ).c_str() );
+                                        stmtsToAddBefore.push_back( ctorStmt );
+
+                                // Return the retVal object.
+                                ast::ReturnStmt * mutStmt = ast::mutate( stmt );
+                                mutStmt->expr = new ast::VariableExpr(
+                                        stmt->location, retDecl );
+                                return mutStmt;
+                        }
+                }
+                return stmt;
+        }
+
+} // namespace
+
+        void genInit( ast::TranslationUnit & transUnit ) {
+                ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
+                ast::Pass<ReturnFixer_New>::run( transUnit );
+        }
+
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<CtorDtor> ctordtor;

src/InitTweak/GenInit.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:31:19 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 22 16:08:00 2021
+// Update Count     : 6
 //
 
@@ -27 +27 @@
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
+        void genInit( ast::TranslationUnit & translationUnit );
 
         /// Converts return statements into copy constructor calls on the hidden return variable

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Sep 11 08:20:44 2021
-// Update Count     : 5040
+// Last Modified On : Fri Oct 15 09:20:17 2021
+// Update Count     : 5163
 //
 
@@ -31 +31 @@
 // from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
 
-// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions. All of the
 // syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
 // fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
@@ -69 +69 @@
         // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
         //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
-        //    i.e., u"a" U"b" L"c" is disallowed.
+        //    e.g., u"a" U"b" L"c" is disallowed.
 
         if ( from[0] != '"' ) {                                                         // encoding ?
@@ -310 +310 @@
 %token ATassign                                                                                 // @=
 
-%type<tok> identifier
-%type<tok> identifier_or_type_name  attr_name
+%type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
@@ -327 +326 @@
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
-%type<en> argument_expression_list_opt  argument_expression                     default_initializer_opt
+%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
@@ -559 +558 @@
         IDENTIFIER
         | quasi_keyword
+        ;
+
+identifier_at:
+        identifier
         | '@'                                                                                           // CFA
                 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
@@ -693 +696 @@
         // empty
                 { $$ = nullptr; }
-        | argument_expression
+        | argument_expression_list
+        ;
+
+argument_expression_list:
+        argument_expression
         | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
@@ -731 +738 @@
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
-        | identifier fraction_constants_opt
+        | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
                 {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
@@ -1084 +1091 @@
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                // { SemanticError( yylloc, "Mutex expression is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1182 +1192 @@
 
 iteration_statement:
-        WHILE '(' push if_control_expression ')' statement pop
-                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
-        | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
+        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
-        | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
-        | FOR '(' push for_control_expression_list ')' statement pop
-                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement     %prec THEN
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1339 +1355 @@
 with_statement:
         WITH '(' tuple_expression_list ')' statement
-                {
-                        $$ = new StatementNode( build_with( $3, $5 ) );
-                }
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
         ;
 
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
-        MUTEX '(' argument_expression_list_opt ')' statement
+        MUTEX '(' argument_expression_list ')' statement
                 { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
         ;
@@ -2475 +2489 @@
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
-        | identifier ':'                                                                        // GCC, field name
+        | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
         ;
@@ -2487 +2501 @@
 
 designator:
-        '.' identifier                                                                          // C99, field name
+        '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
@@ -2919 +2933 @@
 
 paren_identifier:
-        identifier
+        identifier_at
                 { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Henry Xue
-// Last Modified On : Mon Aug 23 15:42:08 2021
-// Update Count     : 650
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 22 16:06:00 2021
+// Update Count     : 653
 //
 
@@ -43 +43 @@
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
+#include "Common/DeclStats.hpp"             // for printDeclStats
+#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"
 #include "Common/PassVisitor.h"
@@ -334 +336 @@
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
-                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
-
-                if ( libcfap ) {
-                        // generate the bodies of cfa library functions
-                        LibCfa::makeLibCfa( translationUnit );
-                } // if
-
-                if ( declstatsp ) {
-                        CodeTools::printDeclStats( translationUnit );
-                        deleteAll( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
-
-                if ( bresolvep ) {
-                        dump( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
 
                 CodeTools::fillLocations( translationUnit );
-
-                if ( resolvprotop ) {
-                        CodeTools::dumpAsResolvProto( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
 
                 if( useNewAST ) {
@@ -366 +346 @@
                         auto transUnit = convert( move( translationUnit ) );
 
+                        forceFillCodeLocations( transUnit );
+
+                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
-                        
+
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( transUnit );
+                        } // if
+
+                        if ( declstatsp ) {
+                                printDeclStats( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        if ( bresolvep ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        if ( resolvprotop ) {
+                                dumpAsResolverProto( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
@@ -377 +380 @@
 
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( translationUnit );
+                        } // if
+
+                        if ( declstatsp ) {
+                                CodeTools::printDeclStats( translationUnit );
+                                deleteAll( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        if ( bresolvep ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        CodeTools::fillLocations( translationUnit );
+
+                        if ( resolvprotop ) {
+                                CodeTools::dumpAsResolvProto( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
 
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );