Changeset e5628db for src/AST

Timestamp:

May 12, 2022, 3:10:58 PM (3 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

8060b2b, f835806

Parents:

f75e25b (diff), 491bb81 (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:

• Convert.cpp (modified) (3 diffs)
• Copy.cpp (modified) (2 diffs)
• Decl.cpp (modified) (3 diffs)
• Decl.hpp (modified) (2 diffs)
• Expr.hpp (modified) (1 diff)
• Label.hpp (modified) (1 diff)
• Node.hpp (modified) (2 diffs)
• Pass.proto.hpp (modified) (3 diffs)
• Stmt.cpp (modified) (2 diffs)
• Stmt.hpp (modified) (2 diffs)
• Util.cpp (modified) (3 diffs)

src/AST/Convert.cpp

@@ -93 +93 @@
         };
 
-    template<typename T>
-    Getter<T> get() {
-        return Getter<T>{ *this };
-    }
+        template<typename T>
+        Getter<T> get() {
+                return Getter<T>{ *this };
+        }
 
         Label makeLabel(Statement * labelled, const ast::Label& label) {
@@ -1651 +1651 @@
                         // GET_ACCEPT_1(type, FunctionType),
                         std::move(forall),
+                        std::move(assertions),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1664 +1665 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);

src/AST/Copy.cpp

@@ -10 +10 @@
 // Created On       : Thr Nov 11  9:16:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:28:00 2021
-// Update Count     : 0
+// Last Modified On : Tue May  3 16:28:00 2022
+// Update Count     : 1
 //
 
@@ -77 +77 @@
         }
 
+        void postvisit( const UniqueExpr * node ) {
+                readonlyInsert( &node->object );
+        }
+
         void postvisit( const MemberExpr * node ) {
                 readonlyInsert( &node->member );

src/AST/Decl.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 12 16:54:55 2021
-// Update Count     : 23
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:10:00 2022
+// Update Count     : 24
 //
 
@@ -53 +53 @@
 // --- FunctionDecl
 
-FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
         std::vector<ptr<TypeDecl>>&& forall,
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
@@ -74 +74 @@
         }
         this->type = ftype;
+}
+
+FunctionDecl::FunctionDecl( const CodeLocation & location, const std::string & name,
+        std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+: DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
+                params( std::move(params) ), returns( std::move(returns) ),
+                type_params( std::move( forall) ), assertions( std::move( assertions ) ),
+                type( nullptr ), stmts( stmts ) {
+        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        for ( auto & param : this->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto & ret : this->returns ) {
+                type->returns.emplace_back( ret->get_type() );
+        }
+        for ( auto & param : this->type_params ) {
+                type->forall.emplace_back( new TypeInstType( param ) );
+        }
+        for ( auto & assertion : this->assertions ) {
+                type->assertions.emplace_back(
+                        new VariableExpr( assertion->location, assertion ) );
+        }
+        this->type = type;
 }
 

src/AST/Decl.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:25:05 2021
-// Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:09:00 2022
+// Update Count     : 33
 //
 
@@ -135 +135 @@
         std::vector< ptr<Expr> > withExprs;
 
+        // The difference between the two constructors is in how they handle
+        // assertions. The first constructor uses the assertions from the type
+        // parameters, in the style of the old ast, and puts them on the type.
+        // The second takes an explicite list of assertions and builds a list of
+        // references to them on the type.
+
         FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
-        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-        //  stmts( stmts ) {}
+
+        FunctionDecl( const CodeLocation & location, const std::string & name,
+                std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
         const Type * get_type() const override;

src/AST/Expr.hpp

@@ -784 +784 @@
 public:
         ptr<Expr> expr;
-        ptr<ObjectDecl> object;
+        readonly<ObjectDecl> object;
         ptr<VariableExpr> var;
         unsigned long long id;

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

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 25 10:33:00 2022
-// Update Count     : 7
+// Last Modified On : Mon May  9 10:20:00 2022
+// Update Count     : 8
 //
 
@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
-        bool isManaged() const {return strong_count > 0; }
+        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.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 19:01:20 2022
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May  3 15:18:20 2022
+// Update Count     : 4
 //
 
 #include "Stmt.hpp"
 
-
+#include "Copy.hpp"
 #include "DeclReplacer.hpp"
 #include "Type.hpp"
@@ -23 +23 @@
 
 // --- CompoundStmt
-CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids(other.kids) {
+CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids() {
+        // Statements can have weak references to them, if that happens inserting
+        // the original node into the new list will put the original node in a
+        // bad state, where it cannot be mutated. To avoid this, just perform an
+        // additional shallow copy on the statement.
+        for ( const Stmt * kid : other.kids ) {
+                if ( kid->isReferenced() ) {
+                        kids.emplace_back( ast::shallowCopy( kid ) );
+                } else {
+                        kids.emplace_back( kid );
+                }
+        }
+
         // when cloning a compound statement, we may end up cloning declarations which
         // are referred to by VariableExprs throughout the block. Cloning a VariableExpr

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 );
         }