Changeset f53afafb

Timestamp:

Feb 22, 2022, 2:45:47 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

3a038fa

Parents:

5cefa43 (diff), a182ad5 (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:

• benchmark/io/sendfile/consumer.c (added)
• benchmark/io/sendfile/producer.c (added)
• driver/cc1.cc (modified) (3 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (2 diffs)
• libcfa/src/math.trait.hfa (modified) (4 diffs)
• src/AST/AssertAcyclic.cpp (deleted)
• src/AST/AssertAcyclic.hpp (deleted)
• src/AST/Decl.cpp (modified) (1 diff)
• src/AST/Util.cpp (added)
• src/AST/Util.hpp (added)
• src/AST/module.mk (modified) (2 diffs)
• 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/.expect/declarationSpecifier.arm64.txt (modified) (2 diffs)
• tests/.expect/gccExtensions.arm64.txt (modified) (2 diffs)
• tests/.expect/random.arm64.txt (modified) (1 diff)
• tests/meta/dumpable.cfa (modified) (1 diff)

driver/cc1.cc

@@ -10 +10 @@
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 21 09:46:24 2021
-// Update Count     : 419
+// Last Modified On : Thu Feb 17 18:04:23 2022
+// Update Count     : 422
 //
 
@@ -61 +61 @@
 static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "__CFA_FLAG__=" suffix
 
-static void checkEnv1( const char * args[], int & nargs ) { // stage 1
+static void checkEnv1() {                                                               // stage 1
         extern char ** environ;
 
@@ -155 +155 @@
         cerr << "Stage1" << endl;
         #endif // __DEBUG_H__
-        checkEnv1( args, nargs );                                                       // arguments passed via environment variables
+        checkEnv1();                                                                            // arguments passed via environment variables
         #ifdef __DEBUG_H__
         for ( int i = 1; i < argc; i += 1 ) {

libcfa/src/concurrency/kernel/startup.cfa

@@ -18 +18 @@
 
 // C Includes
-#include <errno.h>                                                                              // errno
+#include <errno.h>                                      // errno
 #include <signal.h>
-#include <string.h>                                                                             // strerror
-#include <unistd.h>                                                                             // sysconf
+#include <string.h>                                     // strerror
+#include <unistd.h>                                     // sysconf
 
 extern "C" {
-        #include <limits.h>                                                                     // PTHREAD_STACK_MIN
-        #include <unistd.h>                                                                     // syscall
-        #include <sys/eventfd.h>                                                        // eventfd
-        #include <sys/mman.h>                                                           // mprotect
-        #include <sys/resource.h>                                                       // getrlimit
+        #include <limits.h>                             // PTHREAD_STACK_MIN
+        #include <unistd.h>                             // syscall
+        #include <sys/eventfd.h>                        // eventfd
+        #include <sys/mman.h>                           // mprotect
+        #include <sys/resource.h>                       // getrlimit
 }
 
 // CFA Includes
 #include "kernel_private.hfa"
-#include "startup.hfa"                                                                  // STARTUP_PRIORITY_XXX
+#include "startup.hfa"                                  // STARTUP_PRIORITY_XXX
 #include "limits.hfa"
 #include "math.hfa"
@@ -736 +736 @@
         check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
-        size_t stacksize = DEFAULT_STACK_SIZE;
+        size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
 
         void * stack;

libcfa/src/concurrency/preemption.cfa

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov  6 07:42:13 2020
-// Update Count     : 54
+// Last Modified On : Thu Feb 17 11:18:57 2022
+// Update Count     : 59
 //
 
@@ -243 +243 @@
 //----------
 // special case for preemption since used often
-bool __preemption_enabled() {
+__attribute__((optimize("no-reorder-blocks"))) bool __preemption_enabled() {
         // create a assembler label before
         // marked as clobber all to avoid movement

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
 

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/AST/module.mk

@@ -16 +16 @@
 
 SRC_AST = \
-        AST/AssertAcyclic.cpp \
-        AST/AssertAcyclic.hpp \
         AST/Attribute.cpp \
         AST/Attribute.hpp \
@@ -64 +62 @@
         AST/TypeSubstitution.cpp \
         AST/TypeSubstitution.hpp \
+        AST/Util.cpp \
+        AST/Util.hpp \
         AST/Visitor.hpp
 

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/.expect/declarationSpecifier.arm64.txt

@@ -1132 +1132 @@
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
-signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
@@ -1149 +1149 @@
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
-    {
-        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+
     }
 

tests/.expect/gccExtensions.arm64.txt

@@ -324 +324 @@
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
-signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
@@ -341 +341 @@
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
-    {
-        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+
     }
 

tests/.expect/random.arm64.txt

@@ -1 +1 @@
 õ
 =
-V
+K
 -911259971
 6
--4
+11
 1232105397
 0
-18
+11
 -914096085
 1
-15
+20
 2077092859
 1
-11
+12
 0.677254
 0.678106775246139

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;
         }