Changeset a9ce782

Timestamp:

Feb 7, 2026, 1:40:26 PM (15 hours ago)

Author:

Matthew Au-Yeung <mw2auyeu@…>

Branches:

stuck-waitfor-destruct

Parents:

c7d106a

git-author:

Matthew Au-Yeung <mw2auyeu@…> (02/07/26 13:40:05)

git-committer:

Matthew Au-Yeung <mw2auyeu@…> (02/07/26 13:40:26)

Message:

Add a generated hash to fix stuck waitfor comparing static inline mutex destructors

Files:

• libcfa/src/bits/defs.hfa (modified) (1 diff)
• libcfa/src/concurrency/invoke.h (modified) (4 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (1 diff)
• libcfa/src/concurrency/monitor.cfa (modified) (7 diffs)
• libcfa/src/concurrency/monitor.hfa (modified) (2 diffs)
• libcfa/src/concurrency/thread.cfa (modified) (4 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (1 diff)
• src/Concurrency/Keywords.cpp (modified) (7 diffs)
• src/Concurrency/MutexFuncHash.hpp (added)
• src/Concurrency/Waitfor.cpp (modified) (2 diffs)
• src/Validate/Autogen.cpp (modified) (1 diff)

libcfa/src/bits/defs.hfa

@@ -26 +26 @@
 
 typedef void (* fptr_t)();
+typedef uint64_t func_id_t;
 typedef int_fast16_t __lock_size_t;
 

libcfa/src/concurrency/invoke.h

@@ -159 +159 @@
                 // last function that acquired monitors
                 fptr_t func;
+
+                // hash-based function identity for cross-TU matching
+                func_id_t func_id;
         };
 
@@ -288 +291 @@
                         (this.size){0};
                         (this.func){NULL};
-                }
-
-                static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func) {
+                        (this.func_id){0};
+                }
+
+                static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func, func_id_t func_id) {
                         (this.data){data};
                         (this.size){size};
                         (this.func){func};
+                        (this.func_id){func_id};
                 }
 
@@ -299 +304 @@
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
-                        if( lhs.func != rhs.func ) return false;
+                        // Use hash-based comparison when both sides have a valid func_id,
+                        // otherwise fall back to function pointer comparison (for library code
+                        // like join() that cannot compute the hash at compile time).
+                        if( lhs.func_id != 0 && rhs.func_id != 0 ) {
+                                if( lhs.func_id != rhs.func_id ) return false;
+                        } else {
+                                if( lhs.func != rhs.func ) return false;
+                        }
 
                         // Check that all the monitors match
@@ -314 +326 @@
                         lhs.size = rhs.size;
                         lhs.func = rhs.func;
+                        lhs.func_id = rhs.func_id;
                 }
         }

libcfa/src/concurrency/kernel/startup.cfa

@@ -517 +517 @@
         doregister(curr_cluster, this);
 
-        monitors{ &self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0, (func_id_t)0 };
 }
 

libcfa/src/concurrency/monitor.cfa

@@ -140 +140 @@
 }
 
-static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) {
+static void __dtor_enter( monitor$ * this, fptr_t func, func_id_t func_id, bool join ) {
         thread$ * thrd = active_thread();
         #if defined( __CFA_WITH_VERIFY__ )
@@ -190 +190 @@
         __lock_size_t count = 1;
         monitor$ ** monitors = &this;
-        __monitor_group_t group = { &this, 1, func };
+        __monitor_group_t group = { &this, 1, func, func_id };
         if ( is_accepted( this, group) ) {
                 __cfaabi_dbg_print_safe( "Kernel : mon accepts dtor, block and signal it \n" );
@@ -341 +341 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) libcfa_public {
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func, func_id_t func_id ) libcfa_public {
         thread$ * thrd = active_thread();
 
@@ -355 +355 @@
 
         // Update thread context (needed for conditions)
-        (thrd->monitors){m, count, func};
+        (thrd->monitors){m, count, func, func_id};
 
         // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
-        __monitor_group_t group = {this.m, this.count, func};
+        __monitor_group_t group = {this.m, this.count, func, func_id};
         enter( group );
 
@@ -367 +367 @@
 
 void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) libcfa_public {
-        this{ m, count, 0p };
+        this{ m, count, 0p, 0 };
 }
 
@@ -386 +386 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) libcfa_public {
+void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, func_id_t func_id, bool join ) libcfa_public {
         // optimization
         thread$ * thrd = active_thread();
@@ -400 +400 @@
 
         // Update thread context (needed for conditions)
-        (thrd->monitors){m, 1, func};
-
-        __dtor_enter( this.m, func, join );
+        (thrd->monitors){m, 1, func, func_id};
+
+        __dtor_enter( this.m, func, func_id, join );
 }
 

libcfa/src/concurrency/monitor.hfa

@@ -48 +48 @@
 };
 
-void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)(), func_id_t func_id );
 void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
 void ^?{}( monitor_guard_t & this );
@@ -58 +58 @@
 };
 
-void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join );
+void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), func_id_t func_id, bool join );
 void ^?{}( monitor_dtor_guard_t & this );
 

libcfa/src/concurrency/thread.cfa

@@ -61 +61 @@
 
         doregister(curr_cluster, this);
-        monitors{ &self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0, (func_id_t)0 };
 }
 
@@ -93 +93 @@
     | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 void ?{}( thread_dtor_guard_t & this,
-                T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
+                T & thrd, func_id_t func_id, void(*cancelHandler)(ThreadCancelled(T) &)) {
         monitor$ * m = get_monitor(thrd);
         thread$ * desc = get_thread(thrd);
@@ -100 +100 @@
         void (*dtor)(T& mutex this) = ^?{};
         bool join = cancelHandler != (void(*)(ThreadCancelled(T)&))0;
-        (this.mg){&m, (void(*)())dtor, join};
+        this.func_id = func_id;
+        (this.mg){&m, (void(*)())dtor, func_id, join};
 
 
@@ -172 +173 @@
         | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 T & join( T & this ) {
-        thread_dtor_guard_t guard = { this, defaultResumptionHandler };
+        thread_dtor_guard_t guard = { this, (func_id_t)0, defaultResumptionHandler };
         return this;
 }

libcfa/src/concurrency/thread.hfa

@@ -83 +83 @@
 struct thread_dtor_guard_t {
         monitor_dtor_guard_t mg;
+        func_id_t func_id;
 };
 
 forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled(T))
         | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
-void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
+void ?{}( thread_dtor_guard_t & this, T & thrd, func_id_t func_id, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );
 

src/Concurrency/Keywords.cpp

@@ -29 +29 @@
 #include "Common/Examine.hpp"
 #include "Common/Utility.hpp"
+#include "Concurrency/MutexFuncHash.hpp"
 #include "Common/UniqueName.hpp"
 #include "ControlStruct/LabelGenerator.hpp"
@@ -1077 +1078 @@
 
         // In reverse order:
-        // monitor_dtor_guard_t __guard = { __monitor, func, false };
+        // monitor_dtor_guard_t __guard = { __monitor, func, func_id, false };
         mutBody->push_front(
                 new ast::DeclStmt( location, new ast::ObjectDecl(
@@ -1094 +1095 @@
                                                         generic_func,
                                                         ast::ExplicitCast ) ),
+                                        new ast::SingleInit( location,
+                                                Concurrency::hashMangleExpr( location, func ) ),
                                         new ast::SingleInit( location,
                                                 ast::ConstantExpr::from_bool( location, false ) ),
@@ -1175 +1178 @@
                                                 ast::ExplicitCast
                                         ) ),
+                                        new ast::SingleInit( location,
+                                                Concurrency::hashMangleExpr( location, func ) ),
                                 },
                                 {},
@@ -1475 +1480 @@
 
 ast::CompoundStmt * MutexKeyword::addThreadDtorStatements(
-                const ast::FunctionDecl*, const ast::CompoundStmt * body,
+                const ast::FunctionDecl* func, const ast::CompoundStmt * body,
                 const std::vector<const ast::DeclWithType * > & args ) {
         assert( args.size() == 1 );
@@ -1487 +1492 @@
         const CodeLocation & location = mutBody->location;
 
-        // thread_dtor_guard_t __guard = { this, intptr( 0 ) };
+        // thread_dtor_guard_t __guard = { this, func_id, intptr( 0 ) };
         mutBody->push_front( new ast::DeclStmt(
                 location,
@@ -1500 +1505 @@
                                                 new ast::CastExpr( location,
                                                         new ast::VariableExpr( location, arg ), argType ) ),
+                                        new ast::SingleInit( location,
+                                                Concurrency::hashMangleExpr( location, func ) ),
                                         new ast::SingleInit(
                                                 location,

src/Concurrency/Waitfor.cpp

@@ -22 +22 @@
 #include "InitTweak/InitTweak.hpp"
 #include "ResolvExpr/Resolver.hpp"
+#include "Concurrency/MutexFuncHash.hpp"
 
 #include "AST/Print.hpp"
@@ -331 +332 @@
                 makeAccStmt( location, acceptables, index, "func",
                         funcExpr, context ),
+                makeAccStmt( location, acceptables, index, "func_id",
+                        Concurrency::hashMangleExpr( location,
+                                variableExpr->var.strict_as<ast::DeclWithType>() ),
+                        context ),
                 makeAccStmt( location, acceptables, index, "data",
                         new ast::VariableExpr( location, monitors ), context ),

src/Validate/Autogen.cpp

@@ -402 +402 @@
         }
 
-        ast::FunctionDecl * decl = genProto( "^?{}", { dst }, {} );
-        // For concurrent types, remove static storage and inline specifier, and add
-        // cfa_linkonce attribute so the destructor has external linkage with linkonce
-        // semantics. This is required for waitfor to work correctly across translation
-        // units - the function pointer must be the same everywhere, and cfa_linkonce
-        // ensures only one definition survives linking.
-        if ( isConcurrentType() ) {
-                auto mut = ast::mutate( decl );
-                mut->storage = ast::Storage::Classes();
-                mut->funcSpec = ast::Function::Specs();
-                mut->attributes.push_back( new ast::Attribute( "cfa_linkonce" ) );
-        }
-        return decl;
+        return genProto( "^?{}", { dst }, {} );
 }