Changeset 0957f62 for libcfa/src/concurrency/coroutine.cfa

Timestamp:

Mar 1, 2026, 5:47:54 PM (4 days ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

02e7483

Parents:

8086004

Message:

add routines stack_verify and stack_pointer, in debug mode call stack_verify on front-side of context switch and time-slicing

File:

• libcfa/src/concurrency/coroutine.cfa (modified) (3 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 06:48:19 2025
-// Update Count     : 31
+// Last Modified On : Sun Mar  1 17:36:41 2026
+// Update Count     : 115
 //
 
@@ -326 +326 @@
 void ^?{}( ehm_cleanup & this ) { free( this.ex ); }
 
+void * stack_pointer( coroutine$ * cor ) libcfa_public {
+        if ( active_coroutine() == cor ) {                                      // accessing myself ?
+                void * sp;                                                                              // use my current stack value
+                #if defined( __i386__ )
+                asm( "movl %%esp,%0" : "=m" (sp) : );
+                #elif defined( __x86_64__ )
+                asm( "movq %%rsp,%0" : "=m" (sp) : );
+                #elif defined( __arm_64__ )
+                asm( "mov x9, sp; str x9,%0" : "=m" (sp) : : "x9" );
+                #else
+                        #error Cforall : internal error, unsupported architecture
+                #endif
+                return sp;
+        } else {                                                                                        // accessing another coroutine
+                return cor->context.SP;
+        } // if
+} // stackPointer
+
+void * stack_pointer() libcfa_public { return stack_pointer( active_coroutine() ); }
+
+#define xstr(s) str(s)
+#define str(s) #s
+#define STACK_ERROR 4
+#define STACK_WARNING 16
+
+void stack_verify( coroutine$ * cor ) libcfa_public {
+        void * sp = stack_pointer( cor );                                       // optimizations
+        struct __stack_t * cor_stack = __get_stack( cor );
+        void * safelimit = (void *)((char *)cor_stack->limit + STACK_ERROR * 1024); // space needed for printing abort message and backtrace
+
+        if ( sp < safelimit ) {                                                         // must leave stack space to call abort
+                abort( "Stack overflow detected: stack pointer %p below safe limit %p.\n"
+                           "Possible cause is allocation of large stack frame(s) and/or deep call stack.",
+                           sp, safelimit );
+        } else if ( sp < (void *)((char *)cor_stack->limit + STACK_WARNING * 1024) ) { // must leave stack space to call abort
+                #define STACK_WARNING_MSG "Cforall Runtime warning : within " xstr(STACK_WARNING) "K of stack limit.\n"
+                __cfaabi_bits_write( STDERR_FILENO, STACK_WARNING_MSG, sizeof( STACK_WARNING_MSG ) - 1 );
+        } else if ( sp > cor_stack->base ) {
+                abort( "Stack underflow detected: stack pointer %p above base %p.\n"
+                           "Possible cause is corrupted stack frame via overwriting memory.",
+                           sp, cor_stack->base );
+        } // if
+} // verify
+
+void stack_verify() libcfa_public { return stack_verify( active_coroutine() ); }
+
 bool poll( coroutine$ * cor ) libcfa_public {
         nonlocal_exception * nl_ex = pop_ehm_head( cor );
@@ -351 +397 @@
 // user facing ehm operations
 forall(T & | is_coroutine(T)) {
+        void * stack_pointer( T & cor ) libcfa_public { return stack_pointer( get_coroutine( cor ) ); }
+        void stack_verify( T & cor ) libcfa_public { return stack_verify( get_coroutine( cor ) ); }
+
         // enable/disable non-local exceptions
         void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }