Changeset 9490621

Timestamp:

Feb 11, 2022, 11:00:35 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

51b8582

Parents:

5910fc0

Message:

My work in progress implementation of ForallPointerDecay? for Fangren.

Location:

src

Files:

• AST/Decl.cpp (modified) (1 diff)
• SymTab/Validate.cc (modified) (7 diffs)
• SymTab/Validate.h (modified) (1 diff)
• Validate/ForallPointerDecay.cpp (added)
• Validate/ForallPointerDecay.hpp (added)
• Validate/module.mk (modified) (1 diff)
• main.cc (modified) (4 diffs)

src/AST/Decl.cpp ¶

@@ -39 +39 @@
         if ( uniqueId ) return;  // ensure only set once
         uniqueId = ++lastUniqueId;
-        idMap[ uniqueId ] = this;
+        //idMap[ uniqueId ] = this;
 }
 
 readonly<Decl> Decl::fromId( UniqueId id ) {
+        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.