Changeset 69867ad9 for src

Timestamp:

Apr 30, 2024, 12:08:46 PM (7 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

35897fb

Parents:

caaf424 (diff), 0153dbd (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

Location:

src

Files:

• ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• ResolvExpr/CastCost.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• Validate/HoistStruct.cpp (modified) (5 diffs)
• Validate/ImplementEnumFunc.cpp (modified) (8 diffs)
• main.cc (modified) (2 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -906 +906 @@
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost.incVar();
+                                choice->cost.incSafe();
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -1376 +1376 @@
                         ast::Expr * newExpr = data.combine( nameExpr->location, cost );
 
-                        bool bentConversion = false;
-                        if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
-                                if ( inst->base && inst->base->base ) {
-                                        bentConversion = true;
-                                }
-                        }
-
+                        // bool bentConversion = false;
+                        // if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
+                        //      if ( inst->base && inst->base->base ) {
+                        //              bentConversion = true;
+                        //      }
+                        // }
+
+                        // CandidateRef newCand = std::make_shared<Candidate>(
+                        //      newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
+                        //      cost );
                         CandidateRef newCand = std::make_shared<Candidate>(
-                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
+                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
                                 cost );
-
                         if (newCand->expr->env) {
                                 newCand->env.add(*newCand->expr->env);
@@ -1829 +1831 @@
                                         Cost cost = Cost::zero;
                                         ast::Expr * newExpr = data.combine( expr->location, cost );
+                                        // CandidateRef newCand =
+                                        //      std::make_shared<Candidate>(
+                                        //              newExpr, copy( tenv ), ast::OpenVarSet{},
+                                        //              ast::AssertionSet{}, Cost::safe, cost
+                                        //      );
                                         CandidateRef newCand =
                                                 std::make_shared<Candidate>(
                                                         newExpr, copy( tenv ), ast::OpenVarSet{},
-                                                        ast::AssertionSet{}, Cost::safe, cost
+                                                        ast::AssertionSet{}, Cost::zero, cost
                                                 );
-
                                         if (newCand->expr->env) {
                                                 newCand->env.add(*newCand->expr->env);

src/ResolvExpr/CastCost.cc

@@ -53 +53 @@
                         } else {
                                 cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
+                                if ( Cost::unsafe < cost ) {
+                                        if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                                assert(enumInst->base->base);
+                                                cost = Cost::unsafe;
+                                        }
+                                }
                         }
+                }
+
+                void postvisit( const ast::ZeroType * zero ) {
+                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
+                        // if ( ptr && basicType->isInteger() ) {
+                        //      // needed for, e.g. unsigned long => void *
+                        //      cost = Cost::unsafe;
+                        // } else {
+                        cost = conversionCost( zero, dst, srcIsLvalue, symtab, env );
+                        if ( Cost::unsafe < cost ) {
+                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                        assert(enumInst->base->base);
+                                        cost = Cost::unsafe;
+                                }
+                        }
+                        // }
+                }
+
+                void postvisit( const ast::OneType * one ) {
+                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
+                        // if ( ptr && basicType->isInteger() ) {
+                        //      // needed for, e.g. unsigned long => void *
+                        //      cost = Cost::unsafe;
+                        // } else {
+                        cost = conversionCost( one, dst, srcIsLvalue, symtab, env );
+                        if ( Cost::unsafe < cost ) {
+                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                        assert(enumInst->base->base);
+                                        cost = Cost::unsafe;
+                                }
+                        }
+                        // }
                 }
 
@@ -80 +118 @@
                                         cost = Cost::unsafe;
                                 }
+                        }
+                }
+
+                void postvist( const ast::EnumInstType * ) {
+                        if ( auto basic = dynamic_cast< const ast::BasicType * >(dst) ) {
+                                if ( basic->isInteger() ) cost = Cost::unsafe;
                         }
                 }

src/ResolvExpr/ConversionCost.cc

@@ -284 +284 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::zero;
-                        cost.incUnsafe();
+                        cost = Cost::unsafe;
                 }
         }
@@ -482 +481 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::zero;
-                        cost.incUnsafe();
+                        cost = Cost::unsafe;
                 }
         }
@@ -504 +502 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::zero;
-                        cost.incUnsafe();
+                        cost = Cost::unsafe;
                 }
         }

src/Validate/HoistStruct.cpp

@@ -27 +27 @@
 namespace {
 
+/// Is this a declaration can appear in a struct/union and should be hoisted?
 bool shouldHoist( ast::Decl const * decl ) {
         return dynamic_cast< ast::StructDecl const * >( decl )
@@ -34 +35 @@
 }
 
-/* This pass also does some renaming and internal field alteration, but the
- * complex part is the actual hoisting. Hoisted declarations should always
+/// Helper that updates an InstType if the base name could be updated.
+template<typename InstType>
+InstType const * preInstType( InstType const * type ) {
+        assert( type->base );
+        if ( nullptr == type->base->parent ) return type;
+        auto mut = ast::mutate( type );
+        mut->name = mut->base->name;
+        return mut;
+}
+
+/// Update StructInstType and UnionInstType names.
+struct NameUpdater {
+        ast::StructInstType const * previsit( ast::StructInstType const * type ) {
+                return preInstType( type );
+        }
+
+        ast::UnionInstType const * previsit( ast::UnionInstType const * type ) {
+                return preInstType( type );
+        }
+};
+
+ast::Decl const * updateNames( ast::Decl const * decl ) {
+        ast::Pass<NameUpdater> visitor;
+        return decl->accept( visitor );
+}
+
+/* This pass hoists from structs/unions. Hoisted declarations should always
  * appear before the declaration they are hoisted out of and if two types are
  * nested in the same declaration their order should not change.
+ * It also sets up parent relationships, does name mangling of hoisted types
+ * and updates instance types of the hoisted types.
  */
 struct HoistStructCore final :
@@ -96 +124 @@
                 auto mut = ast::mutate( decl );
                 mut->parent = parent;
-                mut->name = qualifiedName( mut );
                 extendParams( mut->params, parent->params );
                 decl = mut;
@@ -116 +143 @@
                 }
         }
+        // Is this a nested type? Then update the name, after the parent's name
+        // has been updated (hence the post visit).
+        if ( mut->parent ) {
+                mut->name = qualifiedName( mut );
+        // Top level type that has hoisted? Then do a second pass subpass to make
+        // sure we update instance type names after the declaration is renamed.
+        } else if ( !declsToAddBefore.empty() ) {
+                for ( ast::ptr<ast::Decl> & member : mut->members ) {
+                        member = updateNames( member.get() );
+                }
+                for ( ast::ptr<ast::Decl> & declToAdd : declsToAddBefore ) {
+                        declToAdd = updateNames( declToAdd );
+                }
+        }
         return mut;
 }
@@ -167 +208 @@
 }
 
-template<typename InstType>
-InstType const * preInstType( InstType const * type ) {
-        assert( type->base );
-        auto mut = ast::mutate( type );
-        mut->name = mut->base->name;
-        return mut;
-}
-
 ast::StructInstType const * HoistStructCore::previsit( ast::StructInstType const * type ) {
         return preInstType( preCollectionInstType( type ) );

src/Validate/ImplementEnumFunc.cpp

@@ -30 +30 @@
         void genAttrFunctions();
         void genSuccPredPosn();
-        void genSuccPredDecl();
+        // void genSuccPredDecl();
 
         void appendReturnThis(ast::FunctionDecl* decl) {
@@ -73 +73 @@
         const ast::Decl* getDecl() const { return decl; }
 
+        // Implement Bounded trait for enum
+    void genBoundedFunctions();
+        // Implement Serial trait for enum
+        void genSerialTraitFuncs();
+
+        // Bounded trait
+        ast::FunctionDecl* genLowerBoundProto() const;
+        ast::FunctionDecl* genUpperBoundProto() const;
+        void genLowerBoundBody(ast::FunctionDecl* func) const;
+        void genUpperBoundBody(ast::FunctionDecl* func) const;
+
         ast::FunctionDecl* genPosnProto() const;
         ast::FunctionDecl* genLabelProto() const;
         ast::FunctionDecl* genValueProto() const;
+
+        // Serial trait
+        ast::FunctionDecl* genFromIntProto() const;
+        ast::FunctionDecl* genFromInstanceProto() const;
         ast::FunctionDecl* genSuccProto() const;
         ast::FunctionDecl* genPredProto() const;
+
+        void genFromIntBody(ast::FunctionDecl *) const; 
+        void genFromInstanceBody(ast::FunctionDecl *) const;
+        ////////////////
 
         ast::FunctionDecl* genSuccPosProto() const;
@@ -289 +308 @@
 
 ast::FunctionDecl* EnumAttrFuncGenerator::genPosnProto() const {
-        return genProto(
-                "posE",
-                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
-                {new ast::ObjectDecl(getLocation(), "_ret",
-                        new ast::BasicType(ast::BasicKind::UnsignedInt))});
+    return genProto(
+        "posE",
+        {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
+        {new ast::ObjectDecl(getLocation(), "_ret",
+            new ast::BasicType(ast::BasicKind::UnsignedInt))});
 }
 
@@ -313 +332 @@
 }
 
+ast::FunctionDecl* EnumAttrFuncGenerator::genFromIntProto() const {
+        return genProto(
+                "fromInt",
+                {new ast::ObjectDecl(getLocation(), "_i", new ast::BasicType(ast::BasicKind::UnsignedInt))},
+                {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))}
+        );
+}
+
+ast::FunctionDecl* EnumAttrFuncGenerator::genFromInstanceProto() const {
+        return genProto(
+                "fromInstance",
+                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
+                {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))}
+        );
+}
+
+void EnumAttrFuncGenerator::genFromIntBody(ast::FunctionDecl* func) const {
+        auto params = func->params;
+        assert( params.size() == 1 );
+        auto param = params.front();
+        auto castExpr = new ast::CastExpr(
+                func->location,
+                new ast::VariableExpr(func->location, param),
+                new ast::EnumInstType(decl),
+                ast::GeneratedFlag::ExplicitCast
+        );
+        func->stmts = new ast::CompoundStmt(
+                func->location, {new ast::ReturnStmt(func->location, castExpr)}
+        );
+}
+
+void EnumAttrFuncGenerator::genFromInstanceBody(ast::FunctionDecl* func) const {
+        auto params = func->params;
+        assert( params.size() == 1 );
+        auto param = params.front();
+        ast::UntypedExpr* untyped = ast::UntypedExpr::createCall(
+                func->location, "posE", { new ast::VariableExpr(func->location, param) });
+        func->stmts = new ast::CompoundStmt(
+                func->location, {new ast::ReturnStmt(func->location, untyped)}
+        );
+}
+
+void EnumAttrFuncGenerator::genSerialTraitFuncs() {
+        auto fromIntProto = genFromIntProto();
+        produceForwardDecl(fromIntProto);
+        genFromIntBody(fromIntProto);
+        produceDecl(fromIntProto);
+
+        auto fromInstanceProto = genFromInstanceProto();
+        produceForwardDecl(fromInstanceProto);
+        genFromInstanceBody(fromInstanceProto);
+        produceDecl(fromInstanceProto);
+
+        auto succProto = genSuccProto();
+        auto predProto = genPredProto();
+        produceForwardDecl(succProto);
+        produceForwardDecl(predProto);
+}
+
 ast::FunctionDecl* EnumAttrFuncGenerator::genSuccProto() const {
         return genProto(
@@ -327 +405 @@
                 {new ast::ObjectDecl(getLocation(), "_ret",
                                      new ast::EnumInstType(decl))});
+}
+
+ast::FunctionDecl* EnumAttrFuncGenerator::genLowerBoundProto() const {
+    return genProto("lowerBound", {}, {
+        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
+    });
+}
+
+ast::FunctionDecl* EnumAttrFuncGenerator::genUpperBoundProto() const {
+    return genProto("upperBound", {}, {
+        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
+    });
+}
+
+void EnumAttrFuncGenerator::genLowerBoundBody(ast::FunctionDecl* func) const {
+        const CodeLocation & loc = func->location;
+        auto mem = decl->members.front();
+        // auto expr = new ast::QualifiedNameExpr( loc, decl, mem->name );
+        // expr->result = new ast::EnumInstType( decl );
+        auto expr = new ast::NameExpr( loc, mem->name );
+        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});
+}
+
+void EnumAttrFuncGenerator::genUpperBoundBody(ast::FunctionDecl* func) const {
+        const CodeLocation & loc = func->location;
+        auto mem = decl->members.back();
+        auto expr = new ast::NameExpr( loc, mem->name );
+        // expr->result = new ast::EnumInstType( decl );
+        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});    
+}
+
+void EnumAttrFuncGenerator::genBoundedFunctions() {
+        ast::FunctionDecl * upperDecl = genUpperBoundProto();
+        produceForwardDecl(upperDecl);
+        genUpperBoundBody(upperDecl);
+        produceDecl(upperDecl);
+
+        ast::FunctionDecl * lowerDecl = genLowerBoundProto();
+        produceForwardDecl(lowerDecl);
+        genLowerBoundBody(lowerDecl);
+        produceDecl(lowerDecl);
 }
 
@@ -373 +492 @@
                 func->location, "?[?]",
                 {new ast::NameExpr(func->location, arrDecl->name),
-                        new ast::CastExpr(
-                                func->location,
-                                new ast::VariableExpr( func->location, func->params.front() ),
-                                new ast::EnumAttrType( new ast::EnumInstType(decl),
-                                        ast::EnumAttribute::Posn))});
+                new ast::CastExpr(
+                        func->location,
+                        new ast::VariableExpr( func->location, func->params.front() ),
+                        new ast::EnumAttrType( new ast::EnumInstType(decl),
+                                ast::EnumAttribute::Posn))});
         func->stmts = new ast::CompoundStmt(
                 func->location, {new ast::ReturnStmt(func->location, untyped)});
@@ -450 +569 @@
 
 void EnumAttrFuncGenerator::genAttrFunctions() {
-        if (decl->base) {
-                genAttributesDecls(ast::EnumAttribute::Value);
-                genAttributesDecls(ast::EnumAttribute::Label);
-                genAttributesDecls(ast::EnumAttribute::Posn);
-        }
-}
-
-void EnumAttrFuncGenerator::genSuccPredDecl() {
-        if (decl->base) {
-                auto succProto = genSuccProto();
-                auto predProto = genPredProto();
-
-                produceForwardDecl(succProto);
-                produceForwardDecl(predProto);
-        }
-}
+        genAttributesDecls(ast::EnumAttribute::Value);
+        genAttributesDecls(ast::EnumAttribute::Label);
+        genAttributesDecls(ast::EnumAttribute::Posn);   
+}
+
+// void EnumAttrFuncGenerator::genSuccPredDecl() {
+//      auto succProto = genSuccProto();
+//      auto predProto = genPredProto();
+
+//      produceForwardDecl(succProto);
+//      produceForwardDecl(predProto);
+// }
 
 void EnumAttrFuncGenerator::genSuccPredPosn() {
-        if (decl->base) {
-                ast::FunctionDecl* succ = genSuccPredFunc(true);
-                ast::FunctionDecl* pred = genSuccPredFunc(false);
-
-                produceDecl(succ);
-                produceDecl(pred);
-        }
+        ast::FunctionDecl* succ = genSuccPredFunc(true);
+        ast::FunctionDecl* pred = genSuccPredFunc(false);
+
+        produceDecl(succ);
+        produceDecl(pred);
 }
 
@@ -482 +595 @@
         genAttrStandardFuncs();
         genAttrFunctions();
-        genSuccPredDecl();
-        genSuccPredPosn(); // Posn
+        genSerialTraitFuncs();
+        genSuccPredPosn();
+        // problematic
+        genBoundedFunctions();
         // Now export the lists contents.
         decls.splice(decls.end(), forwards);

src/main.cc

@@ -325 +325 @@
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
+                // Need to happen before fixing returns because implementEnumFunc has ReturnStmt
+                
+                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
                 PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit );
                 PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit );
@@ -333 +336 @@
 
                 PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
-                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
-
+                
                 PASS( "Implement Actors", Concurrency::implementActors, transUnit );
                 PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );