Changeset 4b30318b

Timestamp:

Sep 2, 2023, 3:07:49 PM (8 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

6e93819

Parents:

389fbf5 (diff), 8a9a3ab (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

Files:

• libcfa/src/concurrency/coroutine.cfa (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (5 diffs)
• libcfa/src/concurrency/exception.cfa (modified) (1 diff)
• src/InitTweak/FixInitNew.cpp (modified) (1 diff)
• src/Parser/parser.yy (modified) (3 diffs)
• src/ResolvExpr/CurrentObject.cc (modified) (2 diffs)
• src/ResolvExpr/ResolveTypeof.cc (modified) (9 diffs)
• src/ResolvExpr/ResolveTypeof.h (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (1 diff)
• src/Validate/GenericParameter.cpp (modified) (1 diff)
• tests/pybin/settings.py (modified) (1 diff)
• tests/test.py (modified) (1 diff)

libcfa/src/concurrency/coroutine.cfa

@@ -344 +344 @@
 bool poll() libcfa_public { return poll( active_coroutine() ); }
 coroutine$ * resumer() libcfa_public { return active_coroutine()->last; }
+coroutine$ * first_resumer() libcfa_public { return active_coroutine()->starter; }
 
 // user facing ehm operations
@@ -358 +359 @@
 
     coroutine$ * resumer( T & cor ) libcfa_public { return get_coroutine( cor )->last; }
+    coroutine$ * first_resumer( T & cor ) libcfa_public { return get_coroutine( cor )->starter; }
 }
 

libcfa/src/concurrency/coroutine.hfa

@@ -124 +124 @@
         src->state = Active;
 
-        if( unlikely(src->cancellation != 0p) ) {
+        if( unlikely(src->cancellation != 0p && src->cancellation != 1p) ) {
                 __cfactx_coroutine_unwind(src->cancellation, src);
         }
@@ -169 +169 @@
         coroutine$ * dst = get_coroutine(cor);
 
+    // printf("FROM RES src: %p, dest: %p\n", src, dst);
+
         if( unlikely(dst->context.SP == 0p) ) {
                 __stack_prepare(&dst->stack, DEFAULT_STACK_SIZE);
@@ -188 +190 @@
         // always done for performance testing
         $ctx_switch( src, dst );
-        if ( unlikely(dst->cancellation) ) {
+
+        if ( unlikely(src->cancellation == 1p) ) {
+        src->cancellation = 0p;
+        // we know dst hasn't been deallocated
                 __cfaehm_cancelled_coroutine( cor, dst, _default_vtable );
         }
@@ -222 +227 @@
 bool poll();
 coroutine$ * resumer();
+coroutine$ * first_resumer();
 
 forall(T & | is_coroutine(T)) {
@@ -229 +235 @@
     bool checked_poll( T & cor );
     coroutine$ * resumer( T & cor );
+    coroutine$ * first_resumer( T & cor );
 }
 

libcfa/src/concurrency/exception.cfa

@@ -57 +57 @@
         struct coroutine$ * src = (coroutine$ *)stop_param;
         struct coroutine$ * dst = src->last;
-
+    dst->cancellation = 1p;
         $ctx_switch( src, dst );
         abort();

src/InitTweak/FixInitNew.cpp

@@ -573 +573 @@
         assertf( global.dtorDestroy, "Destructor generation requires __destroy_Destructor." );
 
-        const CodeLocation loc = ret->location;
+        const CodeLocation & loc = ret->location;
 
         // generate a __Destructor for ret that calls the destructor

src/Parser/parser.yy

@@ -2691 +2691 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) {
+                        if ( $3 && ($3->storageClasses.any() || $3->type->qualifiers.val != 0 )) {
                                 SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
                         }
@@ -2829 +2829 @@
 
 cfa_abstract_parameter_declaration:                                             // CFA, new & old style parameter declaration
-        abstract_parameter_declaration
+        // empty
+                { $$ = nullptr; }
+        | abstract_parameter_declaration
         | cfa_identifier_parameter_declarator_no_tuple
         | cfa_abstract_tuple
@@ -3854 +3856 @@
                 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
         | '[' push array_type_list pop ']'                                      // CFA
-                { SemanticError( yylloc, "Type array dimension is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newArray( $3, nullptr, false ); }
         | multi_array_dimension
         ;

src/ResolvExpr/CurrentObject.cc

@@ -1045 +1045 @@
                         PRINT( std::cerr << "____untyped: " << expr << std::endl; )
                         auto dit = desigAlts.begin();
-                        if ( auto nexpr = dynamic_cast< const NameExpr * >( expr ) ) {
-                                for ( const Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-
-                                        DesignatorChain & d = *dit;
+
+                        for ( const Type * t : curTypes ) {
+                                assert( dit != desigAlts.end() );
+                                DesignatorChain & d = *dit;
+                                if ( auto nexpr = dynamic_cast< const NameExpr *>( expr ) ) {
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
                                         if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
@@ -1062 +1062 @@
                                                         }
                                                 }
+                                        } else if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
+                                                auto nexpr = dynamic_cast< const NameExpr *>( expr );
+                                                auto res = eval( nexpr ); 
+                                                for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
+                                                        if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) {
+                                                                DesignatorChain d2 = d;
+                                                                d2.emplace_back( new VariableExpr{ expr->location, field } );
+                                                                newDesigAlts.emplace_back( std::move( d2 ) );
+                                                                // newTypes.emplace_back( field->type );
+                                                                newTypes.emplace_back( at->base );
+                                                        }
+                                                }
+
+                                                // d.emplace_back( expr );
+                                                // newDesigAlts.emplace_back( d );
+                                                // newTypes.emplace_back( at->base );
                                         }
 
                                         ++dit;
-                                }
-                        } else {
-                                for ( const Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-
-                                        DesignatorChain & d = *dit;
+                                } else {
                                         if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
                                                 PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; )

src/ResolvExpr/ResolveTypeof.cc

@@ -15 +15 @@
 
 #include "ResolveTypeof.h"
-#include "RenameVars.h"
-
-#include <cassert>               // for assert
+
+#include <cassert>  // for assert
 
 #include "AST/CVQualifiers.hpp"
@@ -25 +24 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"  // for PassVisitor
-#include "Common/utility.h"      // for copy
-#include "Resolver.h"            // for resolveInVoidContext
+#include "Common/PassVisitor.h"   // for PassVisitor
+#include "Common/utility.h"       // for copy
+#include "InitTweak/InitTweak.h"  // for isConstExpr
+#include "RenameVars.h"
+#include "Resolver.h"  // for resolveInVoidContext
+#include "SymTab/Mangler.h"
 #include "SynTree/Expression.h"  // for Expression
 #include "SynTree/Mutator.h"     // for Mutator
 #include "SynTree/Type.h"        // for TypeofType, Type
-#include "SymTab/Mangler.h"
-#include "InitTweak/InitTweak.h" // for isConstExpr
 
 namespace SymTab {
@@ -39 +39 @@
 
 namespace ResolvExpr {
-        namespace {
+namespace {
 #if 0
                 void
@@ -52 +52 @@
         }
 
-        class ResolveTypeof_old : public WithShortCircuiting {
-          public:
+class ResolveTypeof_old : public WithShortCircuiting {
+   public:
                 ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
                 void premutate( TypeofType *typeofType );
                 Type * postmutate( TypeofType *typeofType );
 
-          private:
-                const SymTab::Indexer &indexer;
-        };
+   private:
+    const SymTab::Indexer &indexer;
+};
 
         Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
@@ -71 +71 @@
         }
 
-        Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
+    Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cerr << "resolving typeof: ";
@@ -77 +77 @@
                 std::cerr << std::endl;
 #endif
-                // pass on null expression
+    // pass on null expression
                 if ( ! typeofType->expr ) return typeofType;
 
-                bool isBasetypeof = typeofType->is_basetypeof;
-                auto oldQuals = typeofType->get_qualifiers().val;
-
-                Type* newType;
+    bool isBasetypeof = typeofType->is_basetypeof;
+    auto oldQuals = typeofType->get_qualifiers().val;
+
+    Type* newType;
                 if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
-                        // typeof wrapping type
-                        newType = tyExpr->type;
-                        tyExpr->type = nullptr;
-                        delete tyExpr;
-                } else {
-                        // typeof wrapping expression
+        // typeof wrapping type
+        newType = tyExpr->type;
+        tyExpr->type = nullptr;
+        delete tyExpr;
+    } else {
+        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
-                        newType = newExpr->result;
-                        newExpr->result = nullptr;
-                        delete typeofType;
-                        delete newExpr;
-                }
-
-                // clear qualifiers for base, combine with typeoftype quals in any case
-                if ( isBasetypeof ) {
+        newType = newExpr->result;
+        newExpr->result = nullptr;
+        delete typeofType;
+        delete newExpr;
+    }
+
+    // clear qualifiers for base, combine with typeoftype quals in any case
+    if ( isBasetypeof ) {
                         // replace basetypeof(<enum>) by int
                         if ( dynamic_cast<EnumInstType*>(newType) ) {
@@ -112 +112 @@
                                 = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
                 } else {
-                        newType->get_qualifiers().val |= oldQuals;
-                }
-
-                return newType;
-        }
+        newType->get_qualifiers().val |= oldQuals;
+    }
+
+    return newType;
+}
 
 namespace {
-        struct ResolveTypeof_new : public ast::WithShortCircuiting {
-                const ResolveContext & context;
+struct ResolveTypeof_new : public ast::WithShortCircuiting {
+    const ResolveContext & context;
 
                 ResolveTypeof_new( const ResolveContext & context ) :
@@ -127 +127 @@
                 void previsit( const ast::TypeofType * ) { visit_children = false; }
 
-                const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
-                        // pass on null expression
-                        if ( ! typeofType->expr ) return typeofType;
-
-                        ast::ptr< ast::Type > newType;
-                        if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
-                                // typeof wrapping type
-                                newType = tyExpr->type;
-                        } else {
-                                // typeof wrapping expression
-                                ast::TypeEnvironment dummy;
-                                ast::ptr< ast::Expr > newExpr =
-                                        resolveInVoidContext( typeofType->expr, context, dummy );
-                                assert( newExpr->result && ! newExpr->result->isVoid() );
-                                newType = newExpr->result;
-                        }
-
-                        // clear qualifiers for base, combine with typeoftype quals regardless
-                        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
-                                // replace basetypeof(<enum>) by int
+        const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
+        // pass on null expression
+            if ( ! typeofType->expr ) return typeofType;
+
+            ast::ptr< ast::Type > newType;
+            if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
+            // typeof wrapping type
+            newType = tyExpr->type;
+        } else {
+            // typeof wrapping expression
+            ast::TypeEnvironment dummy;
+            ast::ptr< ast::Expr > newExpr =
+                resolveInVoidContext( typeofType->expr, context, dummy );
+            assert( newExpr->result && ! newExpr->result->isVoid() );
+            newType = newExpr->result;
+        }
+
+        // clear qualifiers for base, combine with typeoftype quals regardless
+        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
+            // replace basetypeof(<enum>) by int
                                 if ( newType.as< ast::EnumInstType >() ) {
                                         newType = new ast::BasicType{
                                                 ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
-                                }
+            }
                                 reset_qualifiers(
                                         newType,
                                         ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
-                        } else {
+        } else {
                                 add_qualifiers( newType, typeofType->qualifiers );
-                        }
-
-                        return newType.release();
-                }
-        };
+        }
+
+        return newType.release();
+    }
+};
 } // anonymous namespace
 
@@ -195 +195 @@
 
 const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) {
-        if (decl->isTypeFixed) {
-                return decl;
-        }
-
-        auto mutDecl = mutate(decl);
-        {
-                auto resolvedType = resolveTypeof(decl->type, context);
-                resolvedType = fixArrayType(resolvedType, context);
-                mutDecl->type = resolvedType;
-        }
-
-        // Do not mangle unnamed variables.
-        if (!mutDecl->name.empty()) {
-                mutDecl->mangleName = Mangle::mangle(mutDecl);
-        }
-
-        mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
-        mutDecl->isTypeFixed = true;
-        return mutDecl;
-}
-
-} // namespace ResolvExpr
+    if (decl->isTypeFixed) {
+        return decl;
+    }
+
+    auto mutDecl = mutate(decl);
+    fixObjectInit(decl, context);
+    {
+        auto resolvedType = resolveTypeof(decl->type, context);
+        resolvedType = fixArrayType(resolvedType, context);
+        mutDecl->type = resolvedType;
+    }
+
+    // Do not mangle unnamed variables.
+    if (!mutDecl->name.empty()) {
+        mutDecl->mangleName = Mangle::mangle(mutDecl);
+    }
+
+    mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
+    mutDecl->isTypeFixed = true;
+    return mutDecl;
+}
+
+const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl,
+                                     const ResolveContext &context) {
+    if (decl->isTypeFixed) {
+        return decl;
+    }
+
+    auto mutDecl = mutate(decl);
+
+    if ( auto mutListInit = mutDecl->init.as<ast::ListInit>() ) {
+        // std::list<ast::Designation *> newDesignations;        
+
+        for ( size_t k = 0; k < mutListInit->designations.size(); k++ ) {
+            const ast::Designation *des = mutListInit->designations[k].get();
+            // Desination here
+            ast::Designation * newDesination = new ast::Designation(des->location);
+
+            if (des->designators.size() == 0) continue;
+
+            // The designator I want to replace
+            const ast::Expr * designator = des->designators.at(0);
+
+            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
+                auto candidates = context.symtab.lookupId(designatorName->name);
+                // Does not work for the overloading case currently
+                // assert( candidates.size() == 1 );
+                if ( candidates.size() != 1 ) return mutDecl;
+                auto candidate = candidates.at(0);
+                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
+                    // determine that is an enumInst, swap it with its const value
+                    assert( candidates.size() == 1 );
+                    const ast::EnumDecl * baseEnum = enumInst->base;
+                    // Need to iterate over all enum value to find the initializer to swap
+                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
+                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
+                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
+                            assert(mem);
+                            if ( mem->init ) {
+                                const ast::SingleInit * memInit = mem->init.as<const ast::SingleInit>();
+                                ast::Expr * initValue = shallowCopy( memInit->value.get() );
+                                newDesination->designators.push_back( initValue );
+                            } else {
+                                SemanticError(des->location, "TODO: Enum Array Designation with no explicit value is not implemented");
+                            }
+                        }
+                    }
+                    if ( newDesination->designators.size() == 0 ) {
+                        SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
+                    }
+                } else {
+                    newDesination->designators.push_back( des->designators.at(0) );
+                }
+            } else {
+                newDesination->designators.push_back( des->designators.at(0) );
+            }
+            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+        }
+    }
+    return mutDecl;
+}
+
+}  // namespace ResolvExpr
 
 // Local Variables: //

src/ResolvExpr/ResolveTypeof.h

@@ -32 +32 @@
         const ast::Type * fixArrayType( const ast::Type *, const ResolveContext & );
         const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & );
+        const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &);
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1507 +1507 @@
                                 if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
                                         // constructed objects cannot be designated
-                                        if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        // if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        if ( InitTweak::isDesignated( mutDecl->init ) ) {
+                                                SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        }
                                         // constructed objects should not have initializers nested too deeply
                                         if ( ! InitTweak::checkInitDepth( mutDecl ) ) SemanticError( mutDecl, "Managed object's initializer is too deep " );

src/Validate/GenericParameter.cpp

@@ -301 +301 @@
 const ast::Expr * TranslateDimensionCore::postvisit(
                 const ast::TypeExpr * expr ) {
-        // Does nothing, except prevents matching ast::Expr (above).
+        if ( auto instType = dynamic_cast<const ast::EnumInstType *>( expr->type.get() ) ) {
+                const ast::EnumDecl * baseEnum = instType->base.get();
+                return ast::ConstantExpr::from_int( expr->location, baseEnum->members.size() );
+        }
         return expr;
 }

tests/pybin/settings.py

@@ -141 +141 @@
         all_install  = [Install(o)      for o in list(dict.fromkeys(options.install))]
         archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
-        invariant    = options.no_invariant
+        invariant    = options.invariant
         continue_    = options.continue_
         dry_run      = options.dry_run # must be called before tools.config_hash()

tests/test.py

@@ -114 +114 @@
         parser.add_argument('--install', help='Run all tests based on installed binaries or tree binaries', type=comma_separated(yes_no), default='no')
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
-        parser.add_argument('--invariant', help='Tell the compiler to check invariants.', action='store_true')
-        parser.add_argument('--no-invariant', help='Tell the compiler not to check invariants.', action='store_false')
+        parser.add_argument('--no-invariant', help='Tell the compiler not to check invariants.', action='store_false', dest='invariant')
+        parser.add_argument('--invariant', help='Tell the compiler to check invariants.', action='store_const', const=True)
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)