Changeset b583113

Timestamp:

Apr 21, 2021, 3:44:58 PM (4 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

578c09a

Parents:

7711064

Message:

Recovered the polymorphic CoroutineCancelled? exception. The interface might need a bit of polish.

Files:

• libcfa/src/concurrency/coroutine.cfa (modified) (4 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (5 diffs)
• libcfa/src/exception.hfa (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (3 diffs)
• src/Virtual/Tables.cc (modified) (6 diffs)
• src/Virtual/Tables.h (modified) (2 diffs)
• tests/exceptions/cancel/coroutine.cfa (modified) (1 diff)

libcfa/src/concurrency/coroutine.cfa

@@ -46 +46 @@
 
 //-----------------------------------------------------------------------------
-EHM_VIRTUAL_TABLE(SomeCoroutineCancelled, std_coroutine_cancelled);
-
 forall(T &)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
@@ -62 +60 @@
 // This code should not be inlined. It is the error path on resume.
 forall(T & | is_coroutine(T))
-void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
+void __cfaehm_cancelled_coroutine(
+                T & cor, $coroutine * desc, _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable ) {
         verify( desc->cancellation );
         desc->state = Cancelled;
@@ -68 +67 @@
 
         // TODO: Remove explitate vtable set once trac#186 is fixed.
-        SomeCoroutineCancelled except;
-        except.virtual_table = &std_coroutine_cancelled;
+        CoroutineCancelled(T) except;
+        except.virtual_table = &_default_vtable;
         except.the_coroutine = &cor;
         except.the_exception = except;
         // Why does this need a cast?
-        throwResume (SomeCoroutineCancelled &)except;
+        throwResume (CoroutineCancelled(T) &)except;
 
         except->virtual_table->free( except );
@@ -146 +145 @@
 // Part of the Public API
 // Not inline since only ever called once per coroutine
-forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
 void prime(T& cor) {
         $coroutine* this = get_coroutine(cor);

libcfa/src/concurrency/coroutine.hfa

@@ -22 +22 @@
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
-EHM_EXCEPTION(SomeCoroutineCancelled)(
-        void * the_coroutine;
-        exception_t * the_exception;
-);
-
-EHM_EXTERN_VTABLE(SomeCoroutineCancelled, std_coroutine_cancelled);
-
 EHM_FORALL_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
         coroutine_t * the_coroutine;
@@ -44 +37 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(SomeCoroutineCancelled)) {
+trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
         void main(T & this);
         $coroutine * get_coroutine(T & this);
@@ -67 +60 @@
 //-----------------------------------------------------------------------------
 // Public coroutine API
-forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
 void prime(T & cor);
 
@@ -137 +130 @@
 
 forall(T & | is_coroutine(T))
-void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
+void __cfaehm_cancelled_coroutine(
+        T & cor, $coroutine * desc, _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable );
 
 // Resume implementation inlined for performance
-forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
 static inline T & resume(T & cor) {
         // optimization : read TLS once and reuse it
@@ -170 +164 @@
         $ctx_switch( src, dst );
         if ( unlikely(dst->cancellation) ) {
-                __cfaehm_cancelled_coroutine( cor, dst );
+                __cfaehm_cancelled_coroutine( cor, dst, _default_vtable );
         }
 

libcfa/src/exception.hfa

@@ -142 +142 @@
                 _EHM_VTABLE_TYPE(exception_name) parameters const &) {} \
 
-#define _EHM_TRAIT_FUNCTION2(exception_name, forall_clause, parameters) \
-        forall_clause _EHM_VTABLE_TYPE(exception_name) parameters const & \
-                        get_exception_vtable(exception_name parameters const & this)
-
 #define __EHM_TRAIT_FUNCTION(exception_name, forall_clause, parameters) \
         forall_clause inline _EHM_VTABLE_TYPE(exception_name) parameters const & \

src/Concurrency/Keywords.cc

@@ -414 +414 @@
                 if ( type_decl && isDestructorFor( decl, type_decl ) )
                         dtor_decl = decl;
-                else if ( vtable_name.empty() )
-                        ;
-                else if( !decl->has_body() )
+                else if ( vtable_name.empty() || !decl->has_body() )
                         ;
                 else if ( auto param = isMainFor( decl, cast_target ) ) {
@@ -428 +426 @@
                         std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
                         ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                "_default_vtable_object_declaration",
                                 vtable_decl->makeInst( poly_args ), struct_type, nullptr );
                         declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back(
+                                new ObjectDecl(
+                                        Virtual::concurrentDefaultVTableName(),
+                                        Type::Const,
+                                        LinkageSpec::Cforall,
+                                        /* bitfieldWidth */ nullptr,
+                                        new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                        new SingleInit( new VariableExpr( vtable_object ) )
+                                )
+                        );
                         declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
                                 vtable_object, except_decl->makeInst( std::move( poly_args ) )
@@ -488 +497 @@
                         except_decl->makeInst( poly_args )
                 ) );
-                declsToAddBefore.push_back( Virtual::makeVtableForward(
-                        vtable_decl->makeInst( move( poly_args ) ) ) );
+                ObjectDecl * vtable_object = Virtual::makeVtableForward(
+                        "_default_vtable_object_declaration",
+                        vtable_decl->makeInst( move( poly_args ) ) );
+                declsToAddBefore.push_back( vtable_object );
+                declsToAddAfter.push_back(
+                        new ObjectDecl(
+                                Virtual::concurrentDefaultVTableName(),
+                                Type::Const,
+                                LinkageSpec::Cforall,
+                                /* bitfieldWidth */ nullptr,
+                                new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                /* init */ nullptr
+                        )
+                );
         }
 

src/Virtual/Tables.cc

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:11:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Apr  8 15:51:00 2021
-// Update Count     : 1
+// Last Modified On : Wed Apr 21 15:36:00 2021
+// Update Count     : 2
 //
 
@@ -50 +50 @@
 }
 
+std::string concurrentDefaultVTableName() {
+        return "_default_vtable";
+}
+
 bool isVTableInstanceName( std::string const & name ) {
         // There are some delicate length calculations here.
@@ -57 +61 @@
 
 static ObjectDecl * makeVtableDeclaration(
+                std::string const & name,
                 StructInstType * type, Initializer * init ) {
-        std::string const & name = instanceName( type->name );
         Type::StorageClasses storage = noStorageClasses;
         if ( nullptr == init ) {
@@ -73 +77 @@
 }
 
-ObjectDecl * makeVtableForward( StructInstType * type ) {
+ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
         assert( type );
-        return makeVtableDeclaration( type, nullptr );
+        return makeVtableDeclaration( name, type, nullptr );
 }
 
 ObjectDecl * makeVtableInstance(
-                StructInstType * vtableType, Type * objectType, Initializer * init ) {
+                std::string const & name, StructInstType * vtableType,
+                Type * objectType, Initializer * init ) {
         assert( vtableType );
         assert( objectType );
@@ -115 +120 @@
                 assert(false);
         }
-        return makeVtableDeclaration( vtableType, init );
+        return makeVtableDeclaration( name, vtableType, init );
 }
 
@@ -167 +172 @@
 }
 
-ObjectDecl * makeTypeIdForward() {
-        return nullptr;
-}
-
 Attribute * linkonce( const std::string & subsection ) {
         const std::string section = ".gnu.linkonce." + subsection;

src/Virtual/Tables.h

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:07:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Apr  8 15:55:00 2021
-// Update Count     : 1
+// Last Modified On : Wed Apr 21 10:30:00 2021
+// Update Count     : 2
 //
 
@@ -27 +27 @@
 std::string instanceName( std::string const & vtable_name );
 std::string vtableInstanceName( std::string const & type_name );
+std::string concurrentDefaultVTableName();
 bool isVTableInstanceName( std::string const & name );
 
-ObjectDecl * makeVtableForward( StructInstType * vtableType );
+ObjectDecl * makeVtableForward(
+        std::string const & name, StructInstType * vtableType );
 /* Create a forward declaration of a vtable of the given type.
  * vtableType node is consumed.
  */
 
-ObjectDecl * makeVtableInstance( StructInstType * vtableType, Type * objectType,
+ObjectDecl * makeVtableInstance(
+        std::string const & name,
+        StructInstType * vtableType, Type * objectType,
         Initializer * init = nullptr );
 /* Create an initialized definition of a vtable.

tests/exceptions/cancel/coroutine.cfa

@@ -25 +25 @@
                 resume(cancel);
                 printf("4");
-        } catchResume (SomeCoroutineCancelled * error) {
+        } catchResume (CoroutineCancelled(WillCancel) * error) {
                 printf("2");
                 if ((virtual internal_error *)error->the_exception) {