Changeset 58fe85a for src/AST/Pass.hpp

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (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' into park_unpark

File:

• src/AST/Pass.hpp (modified) (11 diffs)

src/AST/Pass.hpp

@@ -8 +8 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Thu May 09 15::37::05 2019
+// Created On       : Thu May 09 15:37:05 2019
 // Last Modified By :
 // Last Modified On :
@@ -46 +46 @@
 //
 // Several additional features are available through inheritance
-// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the
-//                          current expression
-// | WithStmtsToAdd       - provides the ability to insert statements before or after the current
-//                          statement by adding new statements into stmtsToAddBefore or
-//                          stmtsToAddAfter respectively.
-// | WithDeclsToAdd       - provides the ability to insert declarations before or after the current
-//                          declarations by adding new DeclStmt into declsToAddBefore or
-//                          declsToAddAfter respectively.
-// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children
-//                          to false in pre{visit,visit} to skip visiting children
-// | WithGuards           - provides the ability to save/restore data like a LIFO stack; to save,
-//                          call GuardValue with the variable to save, the variable will
-//                          automatically be restored to its previous value after the corresponding
-//                          postvisit/postmutate teminates.
-// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
-// | WithSymbolTable      - provides symbol table functionality
+// | PureVisitor           - makes the visitor pure, it never modifies nodes in place and always
+//                           clones nodes it needs to make changes to
+// | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs for the
+//                           current expression
+// | WithStmtsToAdd        - provides the ability to insert statements before or after the current
+//                           statement by adding new statements into stmtsToAddBefore or
+//                           stmtsToAddAfter respectively.
+// | WithDeclsToAdd        - provides the ability to insert declarations before or after the
+//                           current declarations by adding new DeclStmt into declsToAddBefore or
+//                           declsToAddAfter respectively.
+// | WithShortCircuiting   - provides the ability to skip visiting child nodes; set visit_children
+//                           to false in pre{visit,visit} to skip visiting children
+// | WithGuards            - provides the ability to save/restore data like a LIFO stack; to save,
+//                           call GuardValue with the variable to save, the variable will
+//                           automatically be restored to its previous value after the
+//                           corresponding postvisit/postmutate teminates.
+// | WithVisitorRef        - provides an pointer to the templated visitor wrapper
+// | WithSymbolTable       - provides symbol table functionality
+//
+// Other Special Members:
+// | result                - Either a method that takes no parameters or a field. If a method (or
+//                           callable field) get_result calls it, otherwise the value is returned.
 //-------------------------------------------------------------------------------------------------
-template< typename pass_t >
+template< typename core_t >
 class Pass final : public ast::Visitor {
 public:
+        using core_type = core_t;
+        using type = Pass<core_t>;
+
         /// Forward any arguments to the pass constructor
         /// Propagate 'this' if necessary
         template< typename... Args >
         Pass( Args &&... args)
-                : pass( std::forward<Args>( args )... )
+                : core( std::forward<Args>( args )... )
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                typedef Pass<pass_t> this_t;
-                this_t * const * visitor = __pass::visitor(pass, 0);
+                type * const * visitor = __pass::visitor(core, 0);
                 if(visitor) {
-                        *const_cast<this_t **>( visitor ) = this;
+                        *const_cast<type **>( visitor ) = this;
                 }
         }
@@ -82 +90 @@
         virtual ~Pass() = default;
 
-        /// Storage for the actual pass
-        pass_t pass;
+        /// Storage for the actual pass.
+        core_t core;
+
+        /// If the core defines a result, call it if possible, otherwise return it.
+        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
+                return __pass::get_result( core, '0' );
+        }
+
+        /// Construct and run a pass on a translation unit.
+        template< typename... Args >
+        static void run( TranslationUnit & decls, Args &&... args ) {
+                Pass<core_t> visitor( std::forward<Args>( args )... );
+                accept_all( decls, visitor );
+        }
+
+        /// Contruct and run a pass on a pointer to extract a value.
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node, Args&&... args ) {
+                Pass<core_t> visitor( std::forward<Args>( args )... );
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
+
+        // Versions of the above for older compilers.
+        template< typename... Args >
+        static void run( TranslationUnit & decls ) {
+                Pass<core_t> visitor;
+                accept_all( decls, visitor );
+        }
+
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node ) {
+                Pass<core_t> visitor;
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
 
         /// Visit function declarations
@@ -111 +155 @@
         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
+        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
@@ -178 +223 @@
         const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) override final;
 
-        template<typename pass_type>
-        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
+        template<typename core_type>
+        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
+
+        bool isInFunction() const {
+                return inFunction;
+        }
+
 private:
 
-        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; }
+        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; }
 
 private:
         const ast::Stmt * call_accept( const ast::Stmt * );
         const ast::Expr * call_accept( const ast::Expr * );
+
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
 
         template< typename node_t >
@@ -206 +260 @@
         void maybe_accept(const node_t * &, child_t parent_t::* child);
 
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
+
 private:
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
-                Pass<pass_t> & pass;
+                guard_symtab( Pass<core_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass.core, 0); }
+                Pass<core_t> & pass;
         };
 
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
-                Pass<pass_t> & pass;
+                guard_scope( Pass<core_t> & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass.core, 0); }
+                Pass<core_t> & pass;
+        };
+
+        /// Internal RAII guard for forall substitutions
+        struct guard_forall_subs {
+                guard_forall_subs( Pass<core_t> & pass, const FunctionType * type )
+                : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); }
+                ~guard_forall_subs()         { __pass::forall::leave(pass.core, 0, type ); }
+                Pass<core_t> & pass;
+                const FunctionType * type;
         };
 
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 
 /// Apply a pass to an entire translation unit
-template<typename pass_t>
-void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
+template<typename core_t>
+void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor );
+
+template<typename core_t>
+void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor );
 
 //-------------------------------------------------------------------------------------------------
@@ -233 +303 @@
 //-------------------------------------------------------------------------------------------------
 
-/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
+/// If used the visitor will always clone nodes.
+struct PureVisitor {};
+
+/// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {
-        const TypeSubstitution * env = nullptr;
+        const TypeSubstitution * typeSubs = nullptr;
 };
 
@@ -267 +340 @@
         };
 
-        template< typename pass_t>
-        friend auto __pass::at_cleanup( pass_t & pass, int ) -> decltype( &pass.at_cleanup );
+        template< typename core_t>
+        friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup );
 public:
 
@@ -304 +377 @@
 
 /// Used to get a pointer to the pass with its wrapped type
-template<typename pass_t>
+template<typename core_t>
 struct WithVisitorRef {
-        Pass<pass_t> * const visitor = nullptr;
+        Pass<core_t> * const visitor = nullptr;
+
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };
 
@@ -313 +390 @@
         SymbolTable symtab;
 };
+
 }
 
@@ -320 +398 @@
 extern struct PassVisitorStats {
         size_t depth = 0;
-        Stats::Counters::MaxCounter<double> * max = nullptr;
-        Stats::Counters::AverageCounter<double> * avg = nullptr;
+        Stats::Counters::MaxCounter<double> * max;
+        Stats::Counters::AverageCounter<double> * avg;
 } pass_visitor_stats;
 }