Changeset 1bc9dcb for src

Timestamp:

Jun 16, 2017, 3:34:55 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

9d85038

Parents:

a724ac1 (diff), d33bc7c (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:

• Common/PassVisitor.h (modified) (3 diffs)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Common/PassVisitor.proto.h (modified) (3 diffs)
• InitTweak/GenInit.cc (modified) (5 diffs)
• tests/preempt_longrun/Makefile.am (added)
• tests/preempt_longrun/Makefile.in (added)
• tests/preempt_longrun/create.c (added)
• tests/preempt_longrun/processor.c (added)
• tests/preempt_longrun/stack.c (added)
• tests/preempt_longrun/yield.c (added)

src/Common/PassVisitor.h

@@ -54 +54 @@
         virtual void visit( BranchStmt *branchStmt ) override final;
         virtual void visit( ReturnStmt *returnStmt ) override final;
+        virtual void visit( ThrowStmt *throwStmt ) override final;
         virtual void visit( TryStmt *tryStmt ) override final;
         virtual void visit( CatchStmt *catchStmt ) override final;
@@ -139 +140 @@
         virtual Statement* mutate( BranchStmt *branchStmt ) override final;
         virtual Statement* mutate( ReturnStmt *returnStmt ) override final;
+        virtual Statement* mutate( ThrowStmt *throwStmt ) override final;
         virtual Statement* mutate( TryStmt *returnStmt ) override final;
         virtual Statement* mutate( CatchStmt *catchStmt ) override final;
@@ -230 +232 @@
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
         bool visit_children() { bool* skip = skip_children_impl(pass, 0); return ! (skip && *skip); }
-};
+        void reset_visit() { bool* skip = skip_children_impl(pass, 0); if(skip) *skip = false; }
+
+        guard_value_impl init_guard() {
+                guard_value_impl guard;
+                auto at_cleanup = at_cleanup_impl(pass, 0);
+                if( at_cleanup ) {
+                        *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) {
+                                guard.push( std::move( func ), val );
+                        };
+                }
+                return guard;
+        }
+};
+
+template<typename pass_type, typename T>
+void GuardValue( pass_type * pass, T& val ) {
+        pass->at_cleanup( [ val ]( void * newVal ) {
+                * static_cast< T * >( newVal ) = val;
+        }, static_cast< void * >( & val ) );
+}
+
+class WithTypeSubstitution {
+protected:
+        WithTypeSubstitution() = default;
+        ~WithTypeSubstitution() = default;
+
+public:
+        TypeSubstitution * env;
+};
+
+class WithStmtsToAdd {
+protected:
+        WithStmtsToAdd() = default;
+        ~WithStmtsToAdd() = default;
+
+public:
+        std::list< Statement* > stmtsToAddBefore;
+        std::list< Statement* > stmtsToAddAfter;
+};
+
+class WithShortCircuiting {
+protected:
+        WithShortCircuiting() = default;
+        ~WithShortCircuiting() = default;
+
+public:
+        bool skip_children;
+};
+
+class WithScopes {
+protected:
+        WithScopes() = default;
+        ~WithScopes() = default;
+
+public:
+        at_cleanup_t at_cleanup;
+
+        template< typename T >
+        void GuardValue( T& val ) {
+                at_cleanup( [ val ]( void * newVal ) {
+                        * static_cast< T * >( newVal ) = val;
+                }, static_cast< void * >( & val ) );
+        }
+};
+
 
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

@@ -1 +1 @@
 #pragma once
 
-#define VISIT_START( node )  \
-        call_previsit( node ); \
-        if( visit_children() ) { \
-
-#define VISIT_END( node )            \
-        }                              \
-        return call_postvisit( node ); \
-
-#define MUTATE_START( node )  \
-        call_premutate( node ); \
-        if( visit_children() ) { \
+#define VISIT_START( node )                     \
+        __attribute__((unused))                   \
+        const auto & guard = init_guard();        \
+        call_previsit( node );                    \
+        if( visit_children() ) {                  \
+                reset_visit();                      \
+
+#define VISIT_END( node )                       \
+        }                                         \
+        call_postvisit( node );                   \
+
+#define MUTATE_START( node )                    \
+        __attribute__((unused))                   \
+        const auto & guard = init_guard();        \
+        call_premutate( node );                   \
+        if( visit_children() ) {                  \
+                reset_visit();                      \
 
 #define MUTATE_END( type, node )                \
@@ -18 +24 @@
 
 
-#define VISIT_BODY( node )    \
-        VISIT_START( node );  \
-        Visitor::visit( node ); \
-        VISIT_END( node ); \
+#define VISIT_BODY( node )        \
+        VISIT_START( node );        \
+        Visitor::visit( node );     \
+        VISIT_END( node );          \
 
 
@@ -389 +395 @@
 
 //--------------------------------------------------------------------------
+// ThrowStmt
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
+        VISIT_BODY( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
+        MUTATE_BODY( Statement, node );
+}
+
+//--------------------------------------------------------------------------
 // TryStmt
 template< typename pass_type >

src/Common/PassVisitor.proto.h

@@ -1 +1 @@
 #pragma once
+
+typedef std::function<void( void * )> cleanup_func_t;
+
+class guard_value_impl {
+public:
+        guard_value_impl() = default;
+
+        ~guard_value_impl() {
+                while( !cleanups.empty() ) {
+                        auto& cleanup = cleanups.top();
+                        cleanup.func( cleanup.val );
+                        cleanups.pop();
+                }
+        }
+
+        void push( cleanup_func_t && func, void* val ) {
+                cleanups.emplace( std::move(func), val );
+        }
+
+private:
+        struct cleanup_t {
+                cleanup_func_t func;
+                void * val;
+
+                cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
+        };
+
+        std::stack< cleanup_t > cleanups;
+};
+
+typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -73 +104 @@
 #define FIELD_PTR( type, name )                                                                                                        \
 template<typename pass_type>                                                                                                           \
-static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) -> decltype( &pass.name ) { return &pass.name; }  \
+static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) -> decltype( &pass.name ) { return &pass.name; } \
                                                                                                                                        \
 template<typename pass_type>                                                                                                           \
@@ -82 +113 @@
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
 FIELD_PTR( bool, skip_children )
+FIELD_PTR( at_cleanup_t, at_cleanup )

src/InitTweak/GenInit.cc

@@ -16 +16 @@
 #include <stack>
 #include <list>
+
+#include "InitTweak.h"
 #include "GenInit.h"
-#include "InitTweak.h"
+
+#include "Common/PassVisitor.h"
+
 #include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+
 #include "SymTab/Autogen.h"
 #include "SymTab/Mangler.h"
+
+#include "GenPoly/DeclMutator.h"
 #include "GenPoly/PolyMutator.h"
-#include "GenPoly/DeclMutator.h"
 #include "GenPoly/ScopedSet.h"
+
 #include "ResolvExpr/typeops.h"
 
@@ -37 +44 @@
         }
 
-        class ReturnFixer final : public GenPoly::PolyMutator {
+        class ReturnFixer : public WithStmtsToAdd, public WithScopes {
           public:
                 /// consistently allocates a temporary variable for the return value
@@ -44 +51 @@
                 static void makeReturnTemp( std::list< Declaration * > &translationUnit );
 
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
-                virtual Statement * mutate( ReturnStmt * returnStmt ) override;
+                void premutate( FunctionDecl *functionDecl );
+                void premutate( ReturnStmt * returnStmt );
 
           protected:
@@ -129 +134 @@
 
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
-                ReturnFixer fixer;
+                PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
         }
 
-        Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
+        void ReturnFixer::premutate( ReturnStmt *returnStmt ) {
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
@@ -144 +149 @@
                         construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
                         construct->get_args().push_back( returnStmt->get_expr() );
-                        stmtsToAdd.push_back(new ExprStmt(noLabels, construct));
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct));
 
                         // return the retVal object
                         returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
                 } // if
-                return returnStmt;
-        }
-
-        DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< FunctionType * > oldFtype( ftype );
-                ValueGuard< std::string > oldFuncName( funcName );
+        }
+
+        void ReturnFixer::premutate( FunctionDecl *functionDecl ) {
+                GuardValue( ftype );
+                GuardValue( funcName );
 
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
-                return Parent::mutate( functionDecl );
         }