Changes in / [a14926b:a7662b8]

Files:

• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/concurrency/locks.hfa (modified) (2 diffs)
• src/AST/Pass.hpp (modified) (2 diffs)
• src/AST/Pass.proto.hpp (modified) (2 diffs)
• src/GenPoly/Box.cc (modified) (3 diffs)

libcfa/src/concurrency/invoke.h

@@ -215 +215 @@
                 struct __thread_user_link cltr_link;
 
+                // used to store state between clh lock/unlock
+                volatile bool * clh_prev;
+
                 // used to point to this thd's current clh node
                 volatile bool * clh_node;

libcfa/src/concurrency/locks.hfa

@@ -228 +228 @@
 struct clh_lock {
         volatile bool * volatile tail;
-    volatile bool * volatile head;
 };
 
@@ -238 +237 @@
         *(curr_thd->clh_node) = false;
         volatile bool * prev = __atomic_exchange_n((bool **)(&l.tail), (bool *)(curr_thd->clh_node), __ATOMIC_SEQ_CST);
-        while(!__atomic_load_n(prev, __ATOMIC_SEQ_CST)) Pause();
-    __atomic_store_n((bool **)(&l.head), (bool *)curr_thd->clh_node, __ATOMIC_SEQ_CST);
-    curr_thd->clh_node = prev;
+        while(!__atomic_load_n(prev, __ATOMIC_ACQUIRE)) Pause();
+        curr_thd->clh_prev = prev;
 }
 
 static inline void unlock(clh_lock & l) {
-        __atomic_store_n((bool *)(l.head), true, __ATOMIC_SEQ_CST);
+        thread$ * curr_thd = active_thread();
+        __atomic_store_n(curr_thd->clh_node, true, __ATOMIC_RELEASE);
+        curr_thd->clh_node = curr_thd->clh_prev;
 }
 

src/AST/Pass.hpp

@@ -86 +86 @@
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                type * const * visitor = __pass::visitor( core, 0 );
-                if ( visitor ) {
+                type * const * visitor = __pass::visitor(core, 0);
+                if(visitor) {
                         *const_cast<type **>( visitor ) = this;
                 }
@@ -98 +98 @@
 
         /// If the core defines a result, call it if possible, otherwise return it.
-        inline auto get_result() -> decltype( __pass::result::get( core, '0' ) ) {
-                return __pass::result::get( core, '0' );
+        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
+                return __pass::get_result( core, '0' );
         }
 

src/AST/Pass.proto.hpp

@@ -489 +489 @@
                 template<typename core_t>
                 static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+
         } // namespace forall
 
@@ -505 +506 @@
         }
 
-        // For passes, usually utility passes, that have a result.
-        namespace result {
-                template<typename core_t>
-                static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
-                        return core.result();
-                }
-
-                template<typename core_t>
-                static inline auto get( core_t & core, int ) -> decltype( core.result ) {
-                        return core.result;
-                }
-
-                template<typename core_t>
-                static inline void get( core_t &, long ) {}
-        }
+        template<typename core_t>
+        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
+                return core.result();
+        }
+
+        template<typename core_t>
+        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
+                return core.result;
+        }
+
+        template<typename core_t>
+        static inline void get_result( core_t &, long ) {}
 } // namespace __pass
 } // namespace ast

src/GenPoly/Box.cc

@@ -424 +424 @@
         namespace {
                 std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
+                        std::stringstream name;
+
                         // NOTE: this function previously used isPolyObj, which failed to produce
                         // the correct thing in some situations. It's not clear to me why this wasn't working.
@@ -430 +432 @@
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
-                        std::stringstream name;
                         for ( DeclarationWithType const * const ret : function->returnVals ) {
-                                name << ( isPolyType( ret->get_type(), tyVars ) ? 'P' : 'M' );
-                        }
-                        name << '_';
+                                if ( isPolyType( ret->get_type(), tyVars ) ) {
+                                        name << "P";
+                                } else {
+                                        name << "M";
+                                }
+                        }
+                        name << "_";
                         for ( DeclarationWithType const * const arg : function->parameters ) {
-                                name << ( isPolyType( arg->get_type(), tyVars ) ? 'P' : 'M' );
-                        }
+                                if ( isPolyType( arg->get_type(), tyVars ) ) {
+                                        name << "P";
+                                } else {
+                                        name << "M";
+                                }
+                        } // for
                         return name.str();
                 }
@@ -556 +565 @@
                         // even when converted to strings, sort in the original order.
                         // (At least, that is the best explination I have.)
-                        for ( std::pair<const std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
+                        for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 if ( !tyParam.second.isComplete ) continue;
                                 Type *concrete = env->lookup( tyParam.first );