source: src/Concurrency/Keywords.cc @ 69c5c00

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 69c5c00 was 69c5c00, checked in by Andrew Beach <ajbeach@…>, 14 months ago

Rework exceptions mark_exception -> get_exception_vtable and the needed follow up.

  • Property mode set to 100644
File size: 33.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Keywords.cc --
8//
9// Author           : Thierry Delisle
10// Created On       : Mon Mar 13 12:41:22 2017
11// Last Modified By :
12// Last Modified On :
13// Update Count     : 10
14//
15
16#include "Concurrency/Keywords.h"
17
18#include <cassert>                        // for assert
19#include <string>                         // for string, operator==
20
21#include <iostream>
22
23#include "Common/Examine.h"               // for isMainFor
24#include "Common/PassVisitor.h"           // for PassVisitor
25#include "Common/SemanticError.h"         // for SemanticError
26#include "Common/utility.h"               // for deleteAll, map_range
27#include "CodeGen/OperatorTable.h"        // for isConstructor
28#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
29#include "InitTweak/InitTweak.h"          // for getPointerBase
30#include "SynTree/LinkageSpec.h"          // for Cforall
31#include "SynTree/Constant.h"             // for Constant
32#include "SynTree/Declaration.h"          // for StructDecl, FunctionDecl, ObjectDecl
33#include "SynTree/Expression.h"           // for VariableExpr, ConstantExpr, Untype...
34#include "SynTree/Initializer.h"          // for SingleInit, ListInit, Initializer ...
35#include "SynTree/Label.h"                // for Label
36#include "SynTree/Statement.h"            // for CompoundStmt, DeclStmt, ExprStmt
37#include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
38#include "SynTree/Visitor.h"              // for Visitor, acceptAll
39#include "Virtual/Tables.h"
40
41class Attribute;
42
43namespace Concurrency {
44        inline static std::string getVTableName( std::string const & exception_name ) {
45                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
46        }
47
48        //=============================================================================================
49        // Pass declarations
50        //=============================================================================================
51
52        //-----------------------------------------------------------------------------
53        //Handles sue type declarations :
54        // sue MyType {                             struct MyType {
55        //      int data;                                  int data;
56        //      a_struct_t more_data;                      a_struct_t more_data;
57        //                                =>             NewField_t newField;
58        // };                                        };
59        //                                           static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
60        //
61        class ConcurrentSueKeyword : public WithDeclsToAdd {
62          public:
63
64                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
65                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
66                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
67                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
68                  context_error( context_error ), exception_name( exception_name ),
69                  vtable_name( getVTableName( exception_name ) ),
70                  needs_main( needs_main ), cast_target( cast_target ) {}
71
72                virtual ~ConcurrentSueKeyword() {}
73
74                Declaration * postmutate( StructDecl * decl );
75                DeclarationWithType * postmutate( FunctionDecl * decl );
76
77                void handle( StructDecl * );
78                void addVtableForward( StructDecl * );
79                FunctionDecl * forwardDeclare( StructDecl * );
80                ObjectDecl * addField( StructDecl * );
81                void addRoutines( ObjectDecl *, FunctionDecl * );
82
83                virtual bool is_target( StructDecl * decl ) = 0;
84
85                Expression * postmutate( KeywordCastExpr * cast );
86
87          private:
88                const std::string type_name;
89                const std::string field_name;
90                const std::string getter_name;
91                const std::string context_error;
92                const std::string exception_name;
93                const std::string vtable_name;
94                bool needs_main;
95                AggregateDecl::Aggregate cast_target;
96
97                StructDecl   * type_decl = nullptr;
98                FunctionDecl * dtor_decl = nullptr;
99                StructDecl * except_decl = nullptr;
100                StructDecl * vtable_decl = nullptr;
101        };
102
103
104        //-----------------------------------------------------------------------------
105        //Handles thread type declarations :
106        // thread Mythread {                         struct MyThread {
107        //      int data;                                  int data;
108        //      a_struct_t more_data;                      a_struct_t more_data;
109        //                                =>             $thread __thrd_d;
110        // };                                        };
111        //                                           static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; }
112        //
113        class ThreadKeyword final : public ConcurrentSueKeyword {
114          public:
115
116                ThreadKeyword() : ConcurrentSueKeyword(
117                        "$thread",
118                        "__thrd",
119                        "get_thread",
120                        "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
121                        "",
122                        true,
123                        AggregateDecl::Thread
124                )
125                {}
126
127                virtual ~ThreadKeyword() {}
128
129                virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
130
131                static void implement( std::list< Declaration * > & translationUnit ) {
132                        PassVisitor< ThreadKeyword > impl;
133                        mutateAll( translationUnit, impl );
134                }
135        };
136
137        //-----------------------------------------------------------------------------
138        //Handles coroutine type declarations :
139        // coroutine MyCoroutine {                   struct MyCoroutine {
140        //      int data;                                  int data;
141        //      a_struct_t more_data;                      a_struct_t more_data;
142        //                                =>             $coroutine __cor_d;
143        // };                                        };
144        //                                           static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
145        //
146        class CoroutineKeyword final : public ConcurrentSueKeyword {
147          public:
148
149                CoroutineKeyword() : ConcurrentSueKeyword(
150                        "$coroutine",
151                        "__cor",
152                        "get_coroutine",
153                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
154                        "CoroutineCancelled",
155                        true,
156                        AggregateDecl::Coroutine
157                )
158                {}
159
160                virtual ~CoroutineKeyword() {}
161
162                virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
163
164                static void implement( std::list< Declaration * > & translationUnit ) {
165                        PassVisitor< CoroutineKeyword > impl;
166                        mutateAll( translationUnit, impl );
167                }
168        };
169
170
171
172        //-----------------------------------------------------------------------------
173        //Handles monitor type declarations :
174        // monitor MyMonitor {                       struct MyMonitor {
175        //      int data;                                  int data;
176        //      a_struct_t more_data;                      a_struct_t more_data;
177        //                                =>             $monitor __mon_d;
178        // };                                        };
179        //                                           static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
180        //
181        class MonitorKeyword final : public ConcurrentSueKeyword {
182          public:
183
184                MonitorKeyword() : ConcurrentSueKeyword(
185                        "$monitor",
186                        "__mon",
187                        "get_monitor",
188                        "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
189                        "",
190                        false,
191                        AggregateDecl::Monitor
192                )
193                {}
194
195                virtual ~MonitorKeyword() {}
196
197                virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
198
199                static void implement( std::list< Declaration * > & translationUnit ) {
200                        PassVisitor< MonitorKeyword > impl;
201                        mutateAll( translationUnit, impl );
202                }
203        };
204
205        //-----------------------------------------------------------------------------
206        //Handles generator type declarations :
207        // generator MyGenerator {                   struct MyGenerator {
208        //      int data;                                  int data;
209        //      a_struct_t more_data;                      a_struct_t more_data;
210        //                                =>             int __gen_next;
211        // };                                        };
212        //
213        class GeneratorKeyword final : public ConcurrentSueKeyword {
214          public:
215
216                GeneratorKeyword() : ConcurrentSueKeyword(
217                        "$generator",
218                        "__generator_state",
219                        "get_generator",
220                        "Unable to find builtin type $generator\n",
221                        "",
222                        true,
223                        AggregateDecl::Generator
224                )
225                {}
226
227                virtual ~GeneratorKeyword() {}
228
229                virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
230
231                static void implement( std::list< Declaration * > & translationUnit ) {
232                        PassVisitor< GeneratorKeyword > impl;
233                        mutateAll( translationUnit, impl );
234                }
235        };
236
237
238        //-----------------------------------------------------------------------------
239        class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
240        public:
241                SuspendKeyword() = default;
242                virtual ~SuspendKeyword() = default;
243
244                void  premutate( FunctionDecl * );
245                DeclarationWithType * postmutate( FunctionDecl * );
246
247                Statement * postmutate( SuspendStmt * );
248
249                static void implement( std::list< Declaration * > & translationUnit ) {
250                        PassVisitor< SuspendKeyword > impl;
251                        mutateAll( translationUnit, impl );
252                }
253
254        private:
255                bool is_real_suspend( FunctionDecl * );
256
257                Statement * make_generator_suspend( SuspendStmt * );
258                Statement * make_coroutine_suspend( SuspendStmt * );
259
260                struct LabelPair {
261                        Label obj;
262                        int   idx;
263                };
264
265                LabelPair make_label() {
266                        labels.push_back( gen.newLabel("generator") );
267                        return { labels.back(), int(labels.size()) };
268                }
269
270                DeclarationWithType * in_generator = nullptr;
271                FunctionDecl * decl_suspend = nullptr;
272                std::vector<Label> labels;
273                ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
274        };
275
276        //-----------------------------------------------------------------------------
277        //Handles mutex routines definitions :
278        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
279        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
280        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
281        //    /*Some code*/                                       =>           /*Some code*/
282        // }                                                               }
283        //
284        class MutexKeyword final {
285          public:
286
287                void postvisit( FunctionDecl * decl );
288                void postvisit(   StructDecl * decl );
289
290                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
291                void validate( DeclarationWithType * );
292                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
293                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
294
295                static void implement( std::list< Declaration * > & translationUnit ) {
296                        PassVisitor< MutexKeyword > impl;
297                        acceptAll( translationUnit, impl );
298                }
299
300          private:
301                StructDecl* monitor_decl = nullptr;
302                StructDecl* guard_decl = nullptr;
303                StructDecl* dtor_guard_decl = nullptr;
304
305                static std::unique_ptr< Type > generic_func;
306        };
307
308        std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
309                new FunctionType(
310                        noQualifiers,
311                        true
312                )
313        );
314
315        //-----------------------------------------------------------------------------
316        //Handles mutex routines definitions :
317        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
318        //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
319        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
320        //    /*Some code*/                                       =>           /*Some code*/
321        // }                                                               }
322        //
323        class ThreadStarter final {
324          public:
325
326                void postvisit( FunctionDecl * decl );
327                void previsit ( StructDecl   * decl );
328
329                void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
330
331                static void implement( std::list< Declaration * > & translationUnit ) {
332                        PassVisitor< ThreadStarter > impl;
333                        acceptAll( translationUnit, impl );
334                }
335
336          private :
337                bool thread_ctor_seen = false;
338                StructDecl * thread_decl = nullptr;
339        };
340
341        //=============================================================================================
342        // General entry routine
343        //=============================================================================================
344        void applyKeywords( std::list< Declaration * > & translationUnit ) {
345                ThreadKeyword   ::implement( translationUnit );
346                CoroutineKeyword        ::implement( translationUnit );
347                MonitorKeyword  ::implement( translationUnit );
348                GeneratorKeyword  ::implement( translationUnit );
349                SuspendKeyword    ::implement( translationUnit );
350        }
351
352        void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
353                MutexKeyword    ::implement( translationUnit );
354        }
355
356        void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
357                ThreadStarter   ::implement( translationUnit );
358        }
359
360        //=============================================================================================
361        // Generic keyword implementation
362        //=============================================================================================
363        void fixupGenerics(FunctionType * func, StructDecl * decl) {
364                cloneAll(decl->parameters, func->forall);
365                for ( TypeDecl * td : func->forall ) {
366                        strict_dynamic_cast<StructInstType*>(
367                                func->parameters.front()->get_type()->stripReferences()
368                        )->parameters.push_back(
369                                new TypeExpr( new TypeInstType( noQualifiers, td->name, td ) )
370                        );
371                }
372        }
373
374        Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) {
375                if( decl->name == type_name && decl->body ) {
376                        assert( !type_decl );
377                        type_decl = decl;
378                }
379                else if ( is_target(decl) ) {
380                        handle( decl );
381                }
382                else if ( !except_decl && exception_name == decl->name && decl->body ) {
383                        except_decl = decl;
384                }
385                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
386                        vtable_decl = decl;
387                }
388                // Might be able to get ride of is target.
389                assert( is_target(decl) == (cast_target == decl->kind) );
390                return decl;
391        }
392
393        DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
394                if ( type_decl && isDestructorFor( decl, type_decl ) )
395                        dtor_decl = decl;
396                else if ( vtable_name.empty() )
397                        ;
398                else if ( auto param = isMainFor( decl, cast_target ) ) {
399                        // This should never trigger.
400                        assert( vtable_decl );
401                        // Should be safe because of isMainFor.
402                        StructInstType * struct_type = static_cast<StructInstType *>(
403                                static_cast<ReferenceType *>( param->get_type() )->base );
404                        assert( struct_type );
405
406                        std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
407                        ObjectDecl * vtable_object = Virtual::makeVtableInstance(
408                                vtable_decl->makeInst( poly_args ), struct_type, nullptr );
409                        declsToAddAfter.push_back( vtable_object );
410                        declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
411                                vtable_object, except_decl->makeInst( std::move( poly_args ) )
412                        ) );
413                }
414
415                return decl;
416        }
417
418        Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
419                if ( cast_target == cast->target ) {
420                        // convert (thread &)t to ($thread &)*get_thread(t), etc.
421                        if( !type_decl ) SemanticError( cast, context_error );
422                        if( !dtor_decl ) SemanticError( cast, context_error );
423                        assert( cast->result == nullptr );
424                        cast->set_result( new ReferenceType( noQualifiers, new StructInstType( noQualifiers, type_decl ) ) );
425                        cast->concrete_target.field  = field_name;
426                        cast->concrete_target.getter = getter_name;
427                }
428                return cast;
429        }
430
431
432        void ConcurrentSueKeyword::handle( StructDecl * decl ) {
433                if( ! decl->body ) return;
434
435                if( !type_decl ) SemanticError( decl, context_error );
436                if( !dtor_decl ) SemanticError( decl, context_error );
437
438                addVtableForward( decl );
439                FunctionDecl * func = forwardDeclare( decl );
440                ObjectDecl * field = addField( decl );
441                addRoutines( field, func );
442        }
443
444        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
445                if ( vtable_decl ) {
446                        std::list< Expression * > poly_args = {
447                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
448                        };
449                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
450                                vtable_decl->makeInst( poly_args ),
451                                except_decl->makeInst( poly_args )
452                        ) );
453                        declsToAddBefore.push_back( Virtual::makeVtableForward(
454                                vtable_decl->makeInst( move( poly_args ) ) ) );
455                // Its only an error if we want a vtable and don't have one.
456                } else if ( ! vtable_name.empty() ) {
457                        SemanticError( decl, context_error );
458                }
459        }
460
461        FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
462
463                StructDecl * forward = decl->clone();
464                forward->set_body( false );
465                deleteAll( forward->get_members() );
466                forward->get_members().clear();
467
468                FunctionType * get_type = new FunctionType( noQualifiers, false );
469                ObjectDecl * this_decl = new ObjectDecl(
470                        "this",
471                        noStorageClasses,
472                        LinkageSpec::Cforall,
473                        nullptr,
474                        new ReferenceType(
475                                noQualifiers,
476                                new StructInstType(
477                                        noQualifiers,
478                                        decl
479                                )
480                        ),
481                        nullptr
482                );
483
484                get_type->get_parameters().push_back( this_decl->clone() );
485                get_type->get_returnVals().push_back(
486                        new ObjectDecl(
487                                "ret",
488                                noStorageClasses,
489                                LinkageSpec::Cforall,
490                                nullptr,
491                                new PointerType(
492                                        noQualifiers,
493                                        new StructInstType(
494                                                noQualifiers,
495                                                type_decl
496                                        )
497                                ),
498                                nullptr
499                        )
500                );
501                fixupGenerics(get_type, decl);
502
503                FunctionDecl * get_decl = new FunctionDecl(
504                        getter_name,
505                        Type::Static,
506                        LinkageSpec::Cforall,
507                        get_type,
508                        nullptr,
509                        { new Attribute("const") },
510                        Type::Inline
511                );
512
513                FunctionDecl * main_decl = nullptr;
514
515                if( needs_main ) {
516                        FunctionType * main_type = new FunctionType( noQualifiers, false );
517
518                        main_type->get_parameters().push_back( this_decl->clone() );
519
520                        main_decl = new FunctionDecl(
521                                "main",
522                                noStorageClasses,
523                                LinkageSpec::Cforall,
524                                main_type,
525                                nullptr
526                        );
527                        fixupGenerics(main_type, decl);
528                }
529
530                delete this_decl;
531
532                declsToAddBefore.push_back( forward );
533                if( needs_main ) declsToAddBefore.push_back( main_decl );
534                declsToAddBefore.push_back( get_decl );
535
536                return get_decl;
537        }
538
539        ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
540                ObjectDecl * field = new ObjectDecl(
541                        field_name,
542                        noStorageClasses,
543                        LinkageSpec::Cforall,
544                        nullptr,
545                        new StructInstType(
546                                noQualifiers,
547                                type_decl
548                        ),
549                        nullptr
550                );
551
552                decl->get_members().push_back( field );
553
554                return field;
555        }
556
557        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
558                CompoundStmt * statement = new CompoundStmt();
559                statement->push_back(
560                        new ReturnStmt(
561                                new AddressExpr(
562                                        new MemberExpr(
563                                                field,
564                                                new CastExpr(
565                                                        new VariableExpr( func->get_functionType()->get_parameters().front() ),
566                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone(),
567                                                        false
568                                                )
569                                        )
570                                )
571                        )
572                );
573
574                FunctionDecl * get_decl = func->clone();
575
576                get_decl->set_statements( statement );
577
578                declsToAddAfter.push_back( get_decl );
579        }
580
581        //=============================================================================================
582        // Suspend keyword implementation
583        //=============================================================================================
584        bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
585                if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
586                if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
587                if(func->type->parameters.size() != 0) return false; // Too many parameters
588                if(func->type->returnVals.size() != 0) return false; // Too many return values
589
590                return true;
591        }
592
593        void SuspendKeyword::premutate( FunctionDecl * func ) {
594                GuardValue(in_generator);
595                in_generator = nullptr;
596
597                // Is this the real suspend?
598                if(is_real_suspend(func)) {
599                        decl_suspend = decl_suspend ? decl_suspend : func;
600                        return;
601                }
602
603                // Is this the main of a generator?
604                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
605                if(!param) return;
606
607                if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
608
609                in_generator = param;
610                GuardValue(labels);
611                labels.clear();
612        }
613
614        DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
615                if( !func->statements ) return func; // Not the actual definition, don't do anything
616                if( !in_generator     ) return func; // Not in a generator, don't do anything
617                if( labels.empty()    ) return func; // Generator has no states, nothing to do, could throw a warning
618
619                // This is a generator main, we need to add the following code to the top
620                // static void * __generator_labels[] = {&&s0, &&s1, ...};
621                // goto * __generator_labels[gen.__generator_state];
622                const auto & loc = func->location;
623
624                const auto first_label = gen.newLabel("generator");
625
626                // for each label add to declaration
627                std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
628                for(const auto & label : labels) {
629                        inits.push_back(
630                                new SingleInit(
631                                        new LabelAddressExpr( label )
632                                )
633                        );
634                }
635                auto init = new ListInit(std::move(inits), noDesignators, true);
636                labels.clear();
637
638                // create decl
639                auto decl = new ObjectDecl(
640                        "__generator_labels",
641                        Type::StorageClasses( Type::Static ),
642                        LinkageSpec::AutoGen,
643                        nullptr,
644                        new ArrayType(
645                                Type::Qualifiers(),
646                                new PointerType(
647                                        Type::Qualifiers(),
648                                        new VoidType( Type::Qualifiers() )
649                                ),
650                                nullptr,
651                                false, false
652                        ),
653                        init
654                );
655
656                // create the goto
657                assert(in_generator);
658
659                auto go_decl = new ObjectDecl(
660                        "__generator_label",
661                        noStorageClasses,
662                        LinkageSpec::AutoGen,
663                        nullptr,
664                        new PointerType(
665                                Type::Qualifiers(),
666                                new VoidType( Type::Qualifiers() )
667                        ),
668                        new SingleInit(
669                                new UntypedExpr(
670                                        new NameExpr("?[?]"),
671                                        {
672                                                new NameExpr("__generator_labels"),
673                                                new UntypedMemberExpr(
674                                                        new NameExpr("__generator_state"),
675                                                        new VariableExpr( in_generator )
676                                                )
677                                        }
678                                )
679                        )
680                );
681                go_decl->location = loc;
682
683                auto go = new BranchStmt(
684                        new VariableExpr( go_decl ),
685                        BranchStmt::Goto
686                );
687                go->location = loc;
688                go->computedTarget->location = loc;
689
690                auto noop = new NullStmt({ first_label });
691                noop->location = loc;
692
693                // wrap everything in a nice compound
694                auto body = new CompoundStmt({
695                        new DeclStmt( decl ),
696                        new DeclStmt( go_decl ),
697                        go,
698                        noop,
699                        func->statements
700                });
701                body->location   = loc;
702                func->statements = body;
703
704                return func;
705        }
706
707        Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
708                SuspendStmt::Type type = stmt->type;
709                if(type == SuspendStmt::None) {
710                        // This suspend has a implicit target, find it
711                        type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
712                }
713
714                // Check that the target makes sense
715                if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
716
717                // Act appropriately
718                switch(type) {
719                        case SuspendStmt::Generator: return make_generator_suspend(stmt);
720                        case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
721                        default: abort();
722                }
723        }
724
725        Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
726                assert(in_generator);
727                // Target code is :
728                //   gen.__generator_state = X;
729                //   { THEN }
730                //   return;
731                //   __gen_X:;
732
733                // Save the location and delete the old statement, we only need the location from this point on
734                auto loc = stmt->location;
735
736                // Build the label and get its index
737                auto label = make_label();
738
739                // Create the context saving statement
740                auto save = new ExprStmt( new UntypedExpr(
741                        new NameExpr( "?=?" ),
742                        {
743                                new UntypedMemberExpr(
744                                        new NameExpr("__generator_state"),
745                                        new VariableExpr( in_generator )
746                                ),
747                                new ConstantExpr(
748                                        Constant::from_int( label.idx )
749                                )
750                        }
751                ));
752                assert(save->expr);
753                save->location = loc;
754                stmtsToAddBefore.push_back( save );
755
756                // if we have a then add it here
757                auto then = stmt->then;
758                stmt->then = nullptr;
759                delete stmt;
760                if(then) stmtsToAddBefore.push_back( then );
761
762                // Create the return statement
763                auto ret = new ReturnStmt( nullptr );
764                ret->location = loc;
765                stmtsToAddBefore.push_back( ret );
766
767                // Create the null statement with the created label
768                auto noop = new NullStmt({ label.obj });
769                noop->location = loc;
770
771                // Return the null statement to take the place of the previous statement
772                return noop;
773        }
774
775        Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
776                if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
777
778                // Save the location and delete the old statement, we only need the location from this point on
779                auto loc = stmt->location;
780                delete stmt;
781
782                // Create the call expression
783                if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
784                auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
785                expr->location = loc;
786
787                // Change this statement into a regular expr
788                assert(expr);
789                auto nstmt = new ExprStmt( expr );
790                nstmt->location = loc;
791                return nstmt;
792        }
793
794
795        //=============================================================================================
796        // Mutex keyword implementation
797        //=============================================================================================
798
799        void MutexKeyword::postvisit(FunctionDecl* decl) {
800
801                bool first = false;
802                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
803                bool isDtor = CodeGen::isDestructor( decl->name );
804
805                // Is this function relevant to monitors
806                if( mutexArgs.empty() ) {
807                        // If this is the destructor for a monitor it must be mutex
808                        if(isDtor) {
809                                Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
810
811                                // If it's a copy, it's not a mutex
812                                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
813                                if( ! rty ) return;
814
815                                // If we are not pointing directly to a type, it's not a mutex
816                                Type* base = rty->get_base();
817                                if( dynamic_cast< ReferenceType * >( base ) ) return;
818                                if( dynamic_cast< PointerType * >( base ) ) return;
819
820                                // Check if its a struct
821                                StructInstType * baseStruct = dynamic_cast< StructInstType * >( base );
822                                if( !baseStruct ) return;
823
824                                // Check if its a monitor
825                                if(baseStruct->baseStruct->is_monitor() || baseStruct->baseStruct->is_thread())
826                                        SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters\n" );
827                        }
828                        return;
829                }
830
831                // Monitors can't be constructed with mutual exclusion
832                if( CodeGen::isConstructor(decl->name) && !first ) SemanticError( decl, "constructors cannot have mutex parameters" );
833
834                // It makes no sense to have multiple mutex parameters for the destructor
835                if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
836
837                // Make sure all the mutex arguments are monitors
838                for(auto arg : mutexArgs) {
839                        validate( arg );
840                }
841
842                // Check if we need to instrument the body
843                CompoundStmt* body = decl->get_statements();
844                if( ! body ) return;
845
846                // Do we have the required headers
847                if( !monitor_decl || !guard_decl || !dtor_guard_decl )
848                        SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor.hfa>\n" );
849
850                // Instrument the body
851                if( isDtor ) {
852                        addDtorStatments( decl, body, mutexArgs );
853                }
854                else {
855                        addStatments( decl, body, mutexArgs );
856                }
857        }
858
859        void MutexKeyword::postvisit(StructDecl* decl) {
860
861                if( decl->name == "$monitor" && decl->body ) {
862                        assert( !monitor_decl );
863                        monitor_decl = decl;
864                }
865                else if( decl->name == "monitor_guard_t" && decl->body ) {
866                        assert( !guard_decl );
867                        guard_decl = decl;
868                }
869                else if( decl->name == "monitor_dtor_guard_t" && decl->body ) {
870                        assert( !dtor_guard_decl );
871                        dtor_guard_decl = decl;
872                }
873        }
874
875        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl, bool & first ) {
876                std::list<DeclarationWithType*> mutexArgs;
877
878                bool once = true;
879                for( auto arg : decl->get_functionType()->get_parameters()) {
880                        //Find mutex arguments
881                        Type* ty = arg->get_type();
882                        if( ! ty->get_mutex() ) continue;
883
884                        if(once) {first = true;}
885                        once = false;
886
887                        //Append it to the list
888                        mutexArgs.push_back( arg );
889                }
890
891                return mutexArgs;
892        }
893
894        void MutexKeyword::validate( DeclarationWithType * arg ) {
895                Type* ty = arg->get_type();
896
897                //Makes sure it's not a copy
898                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
899                if( ! rty ) SemanticError( arg, "Mutex argument must be of reference type " );
900
901                //Make sure the we are pointing directly to a type
902                Type* base = rty->get_base();
903                if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
904                if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
905
906                //Make sure that typed isn't mutex
907                if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
908        }
909
910        void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
911                Type * arg_type = args.front()->get_type()->clone();
912                arg_type->set_mutex( false );
913
914                ObjectDecl * monitors = new ObjectDecl(
915                        "__monitor",
916                        noStorageClasses,
917                        LinkageSpec::Cforall,
918                        nullptr,
919                        new PointerType(
920                                noQualifiers,
921                                new StructInstType(
922                                        noQualifiers,
923                                        monitor_decl
924                                )
925                        ),
926                        new SingleInit( new UntypedExpr(
927                                new NameExpr( "get_monitor" ),
928                                {  new CastExpr( new VariableExpr( args.front() ), arg_type, false ) }
929                        ))
930                );
931
932                assert(generic_func);
933
934                //in reverse order :
935                // monitor_dtor_guard_t __guard = { __monitors, func };
936                body->push_front(
937                        new DeclStmt( new ObjectDecl(
938                                "__guard",
939                                noStorageClasses,
940                                LinkageSpec::Cforall,
941                                nullptr,
942                                new StructInstType(
943                                        noQualifiers,
944                                        dtor_guard_decl
945                                ),
946                                new ListInit(
947                                        {
948                                                new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
949                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
950                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
951                                        },
952                                        noDesignators,
953                                        true
954                                )
955                        ))
956                );
957
958                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
959                body->push_front( new DeclStmt( monitors) );
960        }
961
962        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
963                ObjectDecl * monitors = new ObjectDecl(
964                        "__monitors",
965                        noStorageClasses,
966                        LinkageSpec::Cforall,
967                        nullptr,
968                        new ArrayType(
969                                noQualifiers,
970                                new PointerType(
971                                        noQualifiers,
972                                        new StructInstType(
973                                                noQualifiers,
974                                                monitor_decl
975                                        )
976                                ),
977                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
978                                false,
979                                false
980                        ),
981                        new ListInit(
982                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
983                                        Type * type = var->get_type()->clone();
984                                        type->set_mutex( false );
985                                        return new SingleInit( new UntypedExpr(
986                                                new NameExpr( "get_monitor" ),
987                                                {  new CastExpr( new VariableExpr( var ), type, false ) }
988                                        ) );
989                                })
990                        )
991                );
992
993                assert(generic_func);
994
995                // in reverse order :
996                // monitor_guard_t __guard = { __monitors, #, func };
997                body->push_front(
998                        new DeclStmt( new ObjectDecl(
999                                "__guard",
1000                                noStorageClasses,
1001                                LinkageSpec::Cforall,
1002                                nullptr,
1003                                new StructInstType(
1004                                        noQualifiers,
1005                                        guard_decl
1006                                ),
1007                                new ListInit(
1008                                        {
1009                                                new SingleInit( new VariableExpr( monitors ) ),
1010                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
1011                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
1012                                        },
1013                                        noDesignators,
1014                                        true
1015                                )
1016                        ))
1017                );
1018
1019                //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
1020                body->push_front( new DeclStmt( monitors) );
1021        }
1022
1023        //=============================================================================================
1024        // General entry routine
1025        //=============================================================================================
1026        void ThreadStarter::previsit( StructDecl * decl ) {
1027                if( decl->name == "$thread" && decl->body ) {
1028                        assert( !thread_decl );
1029                        thread_decl = decl;
1030                }
1031        }
1032
1033        void ThreadStarter::postvisit(FunctionDecl * decl) {
1034                if( ! CodeGen::isConstructor(decl->name) ) return;
1035
1036                Type * typeof_this = InitTweak::getTypeofThis(decl->type);
1037                StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this );
1038                if( ctored_type && ctored_type->baseStruct == thread_decl ) {
1039                        thread_ctor_seen = true;
1040                }
1041
1042                DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
1043                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
1044                if( type && type->get_baseStruct()->is_thread() ) {
1045                        if( !thread_decl || !thread_ctor_seen ) {
1046                                SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread.hfa>");
1047                        }
1048
1049                        addStartStatement( decl, param );
1050                }
1051        }
1052
1053        void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
1054                CompoundStmt * stmt = decl->get_statements();
1055
1056                if( ! stmt ) return;
1057
1058                stmt->push_back(
1059                        new ExprStmt(
1060                                new UntypedExpr(
1061                                        new NameExpr( "__thrd_start" ),
1062                                        { new VariableExpr( param ), new NameExpr("main") }
1063                                )
1064                        )
1065                );
1066        }
1067};
1068
1069// Local Variables: //
1070// mode: c //
1071// tab-width: 4 //
1072// End: //
1073
Note: See TracBrowser for help on using the repository browser.