Changeset 90a8125 for src/AST

Timestamp:

Jun 3, 2022, 3:10:01 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

7affcda

Parents:

bf0263c (diff), fc134a48 (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/AST

Files:

• Eval.hpp (deleted)
• Expr.cpp (modified) (5 diffs)
• Expr.hpp (modified) (1 diff)
• Label.hpp (modified) (1 diff)
• Node.hpp (modified) (1 diff)
• Pass.proto.hpp (modified) (3 diffs)
• Stmt.hpp (modified) (2 diffs)
• Util.cpp (modified) (3 diffs)
• module.mk (modified) (1 diff)

src/AST/Expr.cpp

@@ -10 +10 @@
 // Created On       : Wed May 15 17:00:00 2019
 // Last Modified By : Andrew Beach
-// Created On       : Tue Nov 30 14:23:00 2021
-// Update Count     : 7
+// Created On       : Wed May 18 13:56:00 2022
+// Update Count     : 8
 //
 
@@ -21 +21 @@
 
 #include "Copy.hpp"                // for shallowCopy
-#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
 #include "LinkageSpec.hpp"
@@ -67 +66 @@
 // --- UntypedExpr
 
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
+}
+
 UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
-        UntypedExpr * ret = call( loc, "*?", arg );
+        UntypedExpr * ret = createCall( loc, "*?", { arg } );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -87 +91 @@
 }
 
-bool UntypedExpr::get_lvalue() const {
-        std::string fname = InitTweak::getFunctionName( this );
-        return lvalueFunctionNames.count( fname );
-}
-
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 
-        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
+        UntypedExpr * ret = createCall( loc, "?=?", { lhs, rhs } );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -102 +101 @@
         }
         return ret;
+}
+
+UntypedExpr * UntypedExpr::createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args ) {
+        return new UntypedExpr( loc,
+                        new NameExpr( loc, name ), std::move( args ) );
 }
 

src/AST/Expr.hpp

@@ -230 +230 @@
         /// Creates a new assignment expression
         static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
+        /// Creates a new call of a variable.
+        static UntypedExpr * createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Label.hpp

@@ -34 +34 @@
         std::vector< ptr<Attribute> > attributes;
 
-        Label( CodeLocation loc, const std::string& name = "",
+        Label( const CodeLocation& loc, const std::string& name = "",
                 std::vector<ptr<Attribute>> && attrs = std::vector<ptr<Attribute>>{} )
         : location( loc ), name( name ), attributes( attrs ) {}

src/AST/Node.hpp

@@ -51 +51 @@
         bool isManaged() const { return strong_count > 0; }
         bool isReferenced() const { return weak_count > 0; }
+        bool isStable() const {
+                return (1 == strong_count || (1 < strong_count && 0 == weak_count));
+        }
 
 private:

src/AST/Pass.proto.hpp

@@ -131 +131 @@
         template< typename node_t >
         struct result1 {
-                bool differs;
-                const node_t * value;
+                bool differs = false;
+                const node_t * value = nullptr;
 
                 template< typename object_t, typename super_t, typename field_t >
@@ -151 +151 @@
                 };
 
-                bool differs;
+                bool differs = false;
                 container_t< delta > values;
 
@@ -167 +167 @@
         template< template<class...> class container_t, typename node_t >
         struct resultN {
-                bool differs;
+                bool differs = false;
                 container_t<ptr<node_t>> values;
 

src/AST/Stmt.hpp

@@ -58 +58 @@
         // cannot be, they are sub-types of this type, for organization.
 
-    StmtClause( const CodeLocation & loc )
+        StmtClause( const CodeLocation & loc )
                 : ParseNode(loc) {}
 
@@ -396 +396 @@
 class WaitForClause final : public StmtClause {
   public:
-    ptr<Expr> target_func;
-    std::vector<ptr<Expr>> target_args;
-    ptr<Stmt> stmt;
-    ptr<Expr> cond;
-
-    WaitForClause( const CodeLocation & loc )
+        ptr<Expr> target_func;
+        std::vector<ptr<Expr>> target_args;
+        ptr<Stmt> stmt;
+        ptr<Expr> cond;
+
+        WaitForClause( const CodeLocation & loc )
                 : StmtClause( loc ) {}
 
         const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
   private:
-    WaitForClause * clone() const override { return new WaitForClause{ *this }; }
-    MUTATE_FRIEND
+        WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+        MUTATE_FRIEND
 };
 

src/AST/Util.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Util.hpp -- General utilities for working with the AST.
+// Util.cpp -- General utilities for working with the AST.
 //
 // Author           : Andrew Beach
 // Created On       : Wed Jan 19  9:46:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 11 18:07:00 2022
-// Update Count     : 1
+// Last Modified On : Wed May 11 16:16:00 2022
+// Update Count     : 3
 //
 
@@ -46 +46 @@
 
 /// Check that every note that can has a set CodeLocation.
-struct SetCodeLocationsCore {
-        void previsit( const ParseNode * node ) {
-                assert( node->location.isSet() );
+void isCodeLocationSet( const ParseNode * node ) {
+        assert( node->location.isSet() );
+}
+
+void areLabelLocationsSet( const Stmt * stmt ) {
+        for ( const Label& label : stmt->labels ) {
+                assert( label.location.isSet() );
         }
-};
+}
+
+/// Make sure the reference counts are in a valid combination.
+void isStable( const Node * node ) {
+        assert( node->isStable() );
+}
+
+/// Check that a FunctionDecl is synchronized with it's FunctionType.
+void functionDeclMatchesType( const FunctionDecl * decl ) {
+        // The type is a cache of sorts, if it is missing that is only a
+        // problem if isTypeFixed is set.
+        if ( decl->isTypeFixed ) {
+                assert( decl->type );
+        } else if ( !decl->type ) {
+                return;
+        }
+
+        const FunctionType * type = decl->type;
+
+        // Check that `type->forall` corresponds with `decl->type_params`.
+        assert( type->forall.size() == decl->type_params.size() );
+        // Check that `type->assertions` corresponds with `decl->assertions`.
+        assert( type->assertions.size() == decl->assertions.size() );
+        // Check that `type->params` corresponds with `decl->params`.
+        assert( type->params.size() == decl->params.size() );
+        // Check that `type->returns` corresponds with `decl->returns`.
+        assert( type->returns.size() == decl->returns.size() );
+}
 
 struct InvariantCore {
@@ -56 +87 @@
         // None of the passes should make changes so ordering doesn't matter.
         NoStrongCyclesCore no_strong_cycles;
-        SetCodeLocationsCore set_code_locations;
 
         void previsit( const Node * node ) {
                 no_strong_cycles.previsit( node );
+                isStable( node );
         }
 
         void previsit( const ParseNode * node ) {
-                no_strong_cycles.previsit( node );
-                set_code_locations.previsit( node );
+                previsit( (const Node *)node );
+                isCodeLocationSet( node );
+        }
+
+        void previsit( const FunctionDecl * node ) {
+                previsit( (const ParseNode *)node );
+                functionDeclMatchesType( node );
+        }
+
+        void previsit( const Stmt * node ) {
+                previsit( (const ParseNode *)node );
+                areLabelLocationsSet( node );
         }
 

src/AST/module.mk

@@ -29 +29 @@
         AST/DeclReplacer.cpp \
         AST/DeclReplacer.hpp \
-        AST/Eval.hpp \
         AST/Expr.cpp \
         AST/Expr.hpp \