Changeset c76bd34 for src/Concurrency/Keywords.cc

Timestamp:

Oct 7, 2020, 4:31:43 PM (5 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

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

Children:

848439f

Parents:

ae2c27a (diff), 597c5d18 (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 into master

File:

• src/Concurrency/Keywords.cc (modified) (17 diffs)

src/Concurrency/Keywords.cc

@@ -19 +19 @@
 #include <string>                         // for string, operator==
 
+#include <iostream>
+
+#include "Common/Examine.h"               // for isMainFor
 #include "Common/PassVisitor.h"           // for PassVisitor
 #include "Common/SemanticError.h"         // for SemanticError
@@ -34 +37 @@
 #include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
 #include "SynTree/Visitor.h"              // for Visitor, acceptAll
+#include "Virtual/Tables.h"
 
 class Attribute;
 
 namespace Concurrency {
+        inline static std::string getVTableName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -54 +62 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
@@ -63 +75 @@
 
                 void handle( StructDecl * );
+                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
@@ -76 +89 @@
                 const std::string getter_name;
                 const std::string context_error;
+                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
@@ -81 +95 @@
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
+                StructDecl * vtable_decl = nullptr;
         };
 
@@ -101 +116 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "",
                         true,
                         AggregateDecl::Thread
@@ -133 +149 @@
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
@@ -167 +184 @@
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "",
                         false,
                         AggregateDecl::Monitor
@@ -198 +216 @@
                         "get_generator",
                         "Unable to find builtin type $generator\n",
+                        "",
                         true,
                         AggregateDecl::Generator
@@ -231 +250 @@
 
         private:
-                DeclarationWithType * is_main( FunctionDecl * );
                 bool is_real_suspend( FunctionDecl * );
 
@@ -359 +377 @@
                         handle( decl );
                 }
+                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
+                        vtable_decl = decl;
+                }
+                // Might be able to get ride of is target.
+                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
         }
 
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
-                if( !type_decl ) return decl;
-                if( !CodeGen::isDestructor( decl->name ) ) return decl;
-
-                auto params = decl->type->parameters;
-                if( params.size() != 1 ) return decl;
-
-                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
-                if( !type ) return decl;
-
-                auto stype = dynamic_cast<StructInstType*>( type->base );
-                if( !stype ) return decl;
-                if( stype->baseStruct != type_decl ) return decl;
-
-                if( !dtor_decl ) dtor_decl = decl;
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+
+                        declsToAddAfter.push_back( Virtual::makeVtableInstance( vtable_decl, {
+                                new TypeExpr( struct_type->clone() ),
+                        }, struct_type, nullptr ) );
+                }
+
                 return decl;
         }
@@ -400 +426 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
+
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        declsToAddBefore.push_back( Virtual::makeVtableForward( vtable_decl, {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        } ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
         }
 
@@ -528 +566 @@
         // Suspend keyword implementation
         //=============================================================================================
-        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
-                if(func->name != "main") return nullptr;
-                if(func->type->parameters.size() != 1) return nullptr;
-
-                auto param = func->type->parameters.front();
-
-                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
-                if(!type) return nullptr;
-
-                auto obj   = dynamic_cast<StructInstType *>(type->base);
-                if(!obj) return nullptr;
-
-                if(!obj->baseStruct->is_generator()) return nullptr;
-
-                return param;
-        }
-
         bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
                 if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
@@ -565 +586 @@
 
                 // Is this the main of a generator?
-                auto param = is_main( func );
+                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
                 if(!param) return;
 
@@ -910 +931 @@
                                         {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
                                         },
                                         noDesignators,
@@ -1033 +1055 @@
 // tab-width: 4 //
 // End: //
+