Changeset fe610ab

Timestamp:

Feb 17, 2022, 6:53:31 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

f69fac7

Parents:

778315e (diff), 9ef9644 (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/Makefile.am (modified) (3 diffs)
• libcfa/src/concurrency/coroutine.cfa (modified) (4 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (5 diffs)
• libcfa/src/heap.cc (added)
• libcfa/src/heap.cfa (deleted)
• libcfa/src/heap.h (added)
• libcfa/src/heap.hfa (deleted)
• libcfa/src/math.trait.hfa (modified) (4 diffs)
• libcfa/src/startup.cfa (modified) (1 diff)
• libcfa/src/stdhdr/malloc.h (modified) (1 diff)
• libcfa/src/stdlib.hfa (modified) (1 diff)
• src/AST/Decl.cpp (modified) (1 diff)
• src/SymTab/Validate.cc (modified) (7 diffs)
• src/SymTab/Validate.h (modified) (1 diff)
• src/Validate/ForallPointerDecay.cpp (added)
• src/Validate/ForallPointerDecay.hpp (added)
• src/Validate/module.mk (modified) (1 diff)
• src/main.cc (modified) (4 diffs)
• tests/meta/dumpable.cfa (modified) (1 diff)

libcfa/src/Makefile.am ¶

@@ -72 +72 @@
         common.hfa \
         fstream.hfa \
-        heap.hfa \
         iostream.hfa \
         iterator.hfa \
@@ -102 +101 @@
         startup.hfa \
         virtual.c \
-        virtual.h
+        virtual.h \
+        heap.cc \
+        heap.h
 
 # not all platforms support concurrency, add option do disable it
@@ -172 +173 @@
 
 -include $(libdeps)
+-include $(DEPDIR)/heap.Plo
 
 thread_libdeps = $(join \

libcfa/src/concurrency/coroutine.cfa ¶

@@ -85 +85 @@
 // minimum feasible stack size in bytes
 static const size_t MinStackSize = 1000;
-extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
-extern int __map_prot;
+
+extern "C" {
+        extern size_t __cfa_page_size;                          // architecture pagesize HACK, should go in proper runtime singleton
+        extern int __map_prot;
+}
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
@@ -157 +160 @@
 [void *, size_t] __stack_alloc( size_t storageSize ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
-        assert(__page_size != 0l);
+        assert(__cfa_page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-        size = ceiling(size, __page_size);
+        size = ceiling(size, __cfa_page_size);
 
         // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
         void * storage;
         #if CFA_COROUTINE_USE_MMAP
-                storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+                storage = mmap(0p, size + __cfa_page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
                 if(storage == ((void*)-1)) {
                         abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
-                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
                         abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                 } // if
-                storage = (void *)(((intptr_t)storage) + __page_size);
+                storage = (void *)(((intptr_t)storage) + __cfa_page_size);
         #else
                 __cfaabi_dbg_debug_do(
-                        storage = memalign( __page_size, size + __page_size );
+                        storage = memalign( __cfa_page_size, size + __cfa_page_size );
                 );
                 __cfaabi_dbg_no_debug_do(
@@ -181 +184 @@
 
                 __cfaabi_dbg_debug_do(
-                        if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
                                 abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
                         }
-                        storage = (void *)(((intptr_t)storage) + __page_size);
+                        storage = (void *)(((intptr_t)storage) + __cfa_page_size);
                 );
         #endif
@@ -198 +201 @@
         #if CFA_COROUTINE_USE_MMAP
                 size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
-                storage = (void *)(((intptr_t)storage) - __page_size);
-                if(munmap(storage, size + __page_size) == -1) {
+                storage = (void *)(((intptr_t)storage) - __cfa_page_size);
+                if(munmap(storage, size + __cfa_page_size) == -1) {
                         abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
         #else
                 __cfaabi_dbg_debug_do(
-                        storage = (char*)(storage) - __page_size;
-                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
+                        storage = (char*)(storage) - __cfa_page_size;
+                        if ( mprotect( storage, __cfa_page_size, __map_prot ) == -1 ) {
                                 abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
                         }

libcfa/src/concurrency/kernel/startup.cfa ¶

@@ -122 +122 @@
 extern "C" {
         struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
-}
-
-extern size_t __page_size;
-extern int __map_prot;
+        extern size_t __cfa_page_size;
+        extern int __map_prot;
+}
 
 //-----------------------------------------------------------------------------
@@ -574 +573 @@
 }
 
-extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
         /* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
@@ -740 +738 @@
         void * stack;
         #if CFA_PROCESSOR_USE_MMAP
-                stacksize = ceiling( stacksize, __page_size ) + __page_size;
+                stacksize = ceiling( stacksize, __cfa_page_size ) + __cfa_page_size;
                 stack = mmap(0p, stacksize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
                 if(stack == ((void*)-1)) {
                         abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
-                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
                         abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                 } // if
         #else
                 __cfaabi_dbg_debug_do(
-                        stack = memalign( __page_size, stacksize + __page_size );
+                        stack = memalign( __cfa_page_size, stacksize + __cfa_page_size );
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
                                 abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                         } // if
@@ -779 +777 @@
                 check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
-                stacksize += __page_size;
+                stacksize += __cfa_page_size;
 
                 if(munmap(stack, stacksize) == -1) {
@@ -787 +785 @@
                 __cfaabi_dbg_debug_do(
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
+                        if ( mprotect( stack, __cfa_page_size, __map_prot ) == -1 ) {
                                 abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                         } // if

libcfa/src/math.trait.hfa ¶

@@ -16 +16 @@
 #pragma once
 
-trait Not( T ) {
-        void ?{}( T &, zero_t );
-        int !?( T );
+trait Not( U ) {
+        void ?{}( U &, zero_t );
+        int !?( U );
 }; // Not
 
@@ -26 +26 @@
 }; // Equality
 
-trait Relational( T | Equality( T ) ) {
-        int ?<?( T, T );
-        int ?<=?( T, T );
-        int ?>?( T, T );
-        int ?>=?( T, T );
+trait Relational( U | Equality( U ) ) {
+        int ?<?( U, U );
+        int ?<=?( U, U );
+        int ?>?( U, U );
+        int ?>=?( U, U );
 }; // Relational
 
@@ -39 +39 @@
 }; // Signed
 
-trait Additive( T | Signed( T ) ) {
-        T ?+?( T, T );
-        T ?-?( T, T );
-        T ?+=?( T &, T );
-        T ?-=?( T &, T );
+trait Additive( U | Signed( U ) ) {
+        U ?+?( U, U );
+        U ?-?( U, U );
+        U ?+=?( U &, U );
+        U ?-=?( U &, U );
 }; // Additive
 
@@ -49 +49 @@
         void ?{}( T &, one_t );
         // T ?++( T & );
-        // T ++?( T &);
+        // T ++?( T & );
         // T ?--( T & );
         // T --?( T & );
 }; // Incdec
 
-trait Multiplicative( T | Incdec( T ) ) {
-        T ?*?( T, T );
-        T ?/?( T, T );
-        T ?%?( T, T );
-        T ?/=?( T &, T );
+trait Multiplicative( U | Incdec( U ) ) {
+        U ?*?( U, U );
+        U ?/?( U, U );
+        U ?%?( U, U );
+        U ?/=?( U &, U );
 }; // Multiplicative
 

libcfa/src/startup.cfa ¶

@@ -27 +27 @@
         void __cfaabi_appready_startup( void ) {
                 tzset();                                                                                // initialize time global variables
-                #ifdef __CFA_DEBUG__
+                #ifdef __CFA_DEBUG__FIXME
                 extern void heapAppStart();
                 heapAppStart();
-                #endif // __CFA_DEBUG__
+                #endif // __CFA_DEBUG__FIXME
         } // __cfaabi_appready_startup
 
         void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
         void __cfaabi_appready_shutdown( void ) {
-                #ifdef __CFA_DEBUG__
+                #ifdef __CFA_DEBUG__FIXME
                 extern void heapAppStop();
                 heapAppStop();
-                #endif // __CFA_DEBUG__
+                #endif // __CFA_DEBUG__FIXME
         } // __cfaabi_appready_shutdown
 

libcfa/src/stdhdr/malloc.h ¶

@@ -18 +18 @@
 } // extern "C"
 
-#include <heap.hfa>
+#include <heap.h>
 
 // Local Variables: //

libcfa/src/stdlib.hfa ¶

@@ -21 +21 @@
 
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
-#include <heap.hfa>
+#include <heap.h>
 
 

src/AST/Decl.cpp ¶

@@ -39 +39 @@
         if ( uniqueId ) return;  // ensure only set once
         uniqueId = ++lastUniqueId;
-        idMap[ uniqueId ] = this;
+        // The extra readonly pointer is causing some reference counting issues.
+        // idMap[ uniqueId ] = this;
 }
 
 readonly<Decl> Decl::fromId( UniqueId id ) {
+        // Right now this map is always empty, so don't use it.
+        assert( false );
         IdMapType::const_iterator i = idMap.find( id );
         if ( i != idMap.end() ) return i->second;

src/SymTab/Validate.cc ¶

@@ -194 +194 @@
         };
 
+        // These structs are the sub-sub-passes of ForallPointerDecay_old.
+
+        struct TraitExpander_old final {
+                void previsit( FunctionType * );
+                void previsit( StructDecl * );
+                void previsit( UnionDecl * );
+        };
+
+        struct AssertionFixer_old final {
+                void previsit( FunctionType * );
+                void previsit( StructDecl * );
+                void previsit( UnionDecl * );
+        };
+
+        struct CheckOperatorTypes_old final {
+                void previsit( ObjectDecl * );
+        };
+
+        struct FixUniqueIds_old final {
+                void previsit( DeclarationWithType * );
+        };
+
         struct ReturnChecker : public WithGuards {
                 /// Checks that return statements return nothing if their return type is void
@@ -386 +408 @@
 
         void validate_D( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ForallPointerDecay_old> fpd;
                 {
                         Stats::Heap::newPass("validate-D");
@@ -394 +415 @@
                         });
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
-                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                                decayForallPointers( translationUnit ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
@@ -454 +475 @@
 
         void decayForallPointers( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ForallPointerDecay_old> fpd;
-                acceptAll( translationUnit, fpd );
+                PassVisitor<TraitExpander_old> te;
+                acceptAll( translationUnit, te );
+                PassVisitor<AssertionFixer_old> af;
+                acceptAll( translationUnit, af );
+                PassVisitor<CheckOperatorTypes_old> cot;
+                acceptAll( translationUnit, cot );
+                PassVisitor<FixUniqueIds_old> fui;
+                acceptAll( translationUnit, fui );
+        }
+
+        void decayForallPointersA( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<TraitExpander_old> te;
+                acceptAll( translationUnit, te );
+        }
+        void decayForallPointersB( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<AssertionFixer_old> af;
+                acceptAll( translationUnit, af );
+        }
+        void decayForallPointersC( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<CheckOperatorTypes_old> cot;
+                acceptAll( translationUnit, cot );
+        }
+        void decayForallPointersD( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<FixUniqueIds_old> fui;
+                acceptAll( translationUnit, fui );
         }
 
@@ -470 +514 @@
                 PassVisitor<EnumAndPointerDecay_old> epc;
                 PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
-                PassVisitor<ForallPointerDecay_old> fpd;
+                PassVisitor<TraitExpander_old> te;
+                PassVisitor<AssertionFixer_old> af;
+                PassVisitor<CheckOperatorTypes_old> cot;
+                PassVisitor<FixUniqueIds_old> fui;
                 type->accept( epc );
                 type->accept( lrt );
-                type->accept( fpd );
+                type->accept( te );
+                type->accept( af );
+                type->accept( cot );
+                type->accept( fui );
         }
 
@@ -972 +1022 @@
         }
 
+        /// Replace all traits in assertion lists with their assertions.
+        void expandTraits( std::list< TypeDecl * > & forall ) {
+                for ( TypeDecl * type : forall ) {
+                        std::list< DeclarationWithType * > asserts;
+                        asserts.splice( asserts.end(), type->assertions );
+                        // expand trait instances into their members
+                        for ( DeclarationWithType * assertion : asserts ) {
+                                if ( TraitInstType * traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
+                                        // expand trait instance into all of its members
+                                        expandAssertions( traitInst, back_inserter( type->assertions ) );
+                                        delete traitInst;
+                                } else {
+                                        // pass other assertions through
+                                        type->assertions.push_back( assertion );
+                                } // if
+                        } // for
+                }
+        }
+
+        /// Fix each function in the assertion list and check for invalid void type.
+        void fixAssertions(
+                        std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
+                for ( TypeDecl * type : forall ) {
+                        for ( DeclarationWithType *& assertion : type->assertions ) {
+                                bool isVoid = fixFunction( assertion );
+                                if ( isVoid ) {
+                                        SemanticError( node, "invalid type void in assertion of function " );
+                                } // if
+                        } // for
+                }
+        }
+
         void ForallPointerDecay_old::previsit( ObjectDecl * object ) {
                 // ensure that operator names only apply to functions or function pointers
@@ -994 +1076 @@
         void ForallPointerDecay_old::previsit( UnionDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
+        }
+
+        void TraitExpander_old::previsit( FunctionType * ftype ) {
+                expandTraits( ftype->forall );
+        }
+
+        void TraitExpander_old::previsit( StructDecl * aggrDecl ) {
+                expandTraits( aggrDecl->parameters );
+        }
+
+        void TraitExpander_old::previsit( UnionDecl * aggrDecl ) {
+                expandTraits( aggrDecl->parameters );
+        }
+
+        void AssertionFixer_old::previsit( FunctionType * ftype ) {
+                fixAssertions( ftype->forall, ftype );
+        }
+
+        void AssertionFixer_old::previsit( StructDecl * aggrDecl ) {
+                fixAssertions( aggrDecl->parameters, aggrDecl );
+        }
+
+        void AssertionFixer_old::previsit( UnionDecl * aggrDecl ) {
+                fixAssertions( aggrDecl->parameters, aggrDecl );
+        }
+
+        void CheckOperatorTypes_old::previsit( ObjectDecl * object ) {
+                // ensure that operator names only apply to functions or function pointers
+                if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
+                        SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." )  );
+                }
+        }
+
+        void FixUniqueIds_old::previsit( DeclarationWithType * decl ) {
+                decl->fixUniqueId();
         }
 

src/SymTab/Validate.h ¶

@@ -43 +43 @@
         void validate_F( std::list< Declaration * > &translationUnit );
         void decayForallPointers( std::list< Declaration * > & translationUnit );
+        void decayForallPointersA( std::list< Declaration * > & translationUnit );
+        void decayForallPointersB( std::list< Declaration * > & translationUnit );
+        void decayForallPointersC( std::list< Declaration * > & translationUnit );
+        void decayForallPointersD( std::list< Declaration * > & translationUnit );
 
         const ast::Type * validateType(

src/Validate/module.mk ¶

@@ -20 +20 @@
         Validate/CompoundLiteral.cpp \
         Validate/CompoundLiteral.hpp \
+        Validate/ForallPointerDecay.cpp \
+        Validate/ForallPointerDecay.hpp \
         Validate/HandleAttributes.cc \
         Validate/HandleAttributes.h \

src/main.cc ¶

@@ -32 +32 @@
 
 #include "AST/Convert.hpp"
+#include "AST/Print.hpp"
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
@@ -76 +77 @@
 #include "Validate/Autogen.hpp"             // for autogenerateRoutines
 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
+#include "Validate/ForallPointerDecay.hpp"  // for decayForallPointers
 #include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
 #include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
@@ -331 +333 @@
 
                 if( useNewAST ) {
-                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
-                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
+                        PASS( "Implement Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
+                        //PASS( "Forall Pointer Decay - A", SymTab::decayForallPointersA( translationUnit ) );
+                        //PASS( "Forall Pointer Decay - B", SymTab::decayForallPointersB( translationUnit ) );
+                        //PASS( "Forall Pointer Decay - C", SymTab::decayForallPointersC( translationUnit ) );
+                        //PASS( "Forall Pointer Decay - D", SymTab::decayForallPointersD( translationUnit ) );
                         CodeTools::fillLocations( translationUnit );
 
@@ -342 +347 @@
 
                         forceFillCodeLocations( transUnit );
+
+                        // Must be after implement concurrent keywords; because uniqueIds
+                        //   must be set on declaration before resolution.
+                        // Must happen before autogen routines are added.
+                        PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
 
                         // Must happen before autogen routines are added.

tests/meta/dumpable.cfa ¶

@@ -72 +72 @@
         }
 
-        if((buf.f_bsize * buf.f_bavail) < 536870912) {
-                serr | "Available diskspace is less than ~500Mb: " | (buf.f_bsize * buf.f_bavail);
+        uint64_t avail = buf.f_bavail;
+        avail *= buf.f_bsize;
+        if(avail < 536870912_l64u) {
+                serr | "Available diskspace is less than ~500Mb: " | avail;
         }