Changeset 59c8dff

Timestamp:

Jan 19, 2024, 2:42:58 AM (20 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

f988834

Parents:

8b4faf6

Message:

Draft Implementation for enum position pesudo function (posE). EnumPosExpr is mostly irrelevant for now. It is used in development/code probing and will be removed later

Location:

src

Files:

• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cpp (modified) (1 diff)
• CodeGen/CodeGenerator.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• GenPoly/Box.cpp (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ExpressionNode.h (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• Validate/Autogen.cpp (modified) (3 diffs)
• Validate/module.mk (modified) (1 diff)
• main.cc (modified) (4 diffs)

src/AST/Expr.cpp

@@ -307 +307 @@
 }
 
+// 
+
+// --- EnumPosExpr
+EnumPosExpr::EnumPosExpr( const CodeLocation & loc, const EnumInstType * ty)
+: Expr( loc, new BasicType{ BasicType::UnsignedInt }), type( ty ) {
+        assert( ty );
+}
+
+EnumPosExpr::EnumPosExpr( const CodeLocation & loc, const Expr * expr )
+: Expr( loc, new BasicType{ BasicType::UnsignedInt }), expr(expr) {
+        assert( expr );
+}
+
+
 // --- LogicalExpr
 

src/AST/Expr.hpp

@@ -548 +548 @@
 };
 
+class EnumPosExpr final : public Expr {
+public:
+        ptr<EnumInstType> type;
+        ptr<Expr> expr;
+        
+        EnumPosExpr( const CodeLocation & loc, const EnumInstType * ty );
+        EnumPosExpr( const CodeLocation & loc, const Expr * expr );
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        EnumPosExpr * clone() const override { return new EnumPosExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Variants of short-circuiting logical expression
 enum LogicalFlag { OrExpr, AndExpr };

src/AST/Fwd.hpp

@@ -89 +89 @@
 class OffsetofExpr;
 class OffsetPackExpr;
+class EnumPosExpr;
 class LogicalExpr;
 class ConditionalExpr;

src/AST/Node.cpp

@@ -232 +232 @@
 template class ast::ptr_base< ast::OffsetPackExpr, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::OffsetPackExpr, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::EnumPosExpr, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::EnumPosExpr, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::LogicalExpr, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::LogicalExpr, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -191 +191 @@
         const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;
         const ast::Expr *             visit( const ast::OffsetPackExpr       * ) override final;
+        const ast::Expr *             visit( const ast::EnumPosExpr          * ) override final;
         const ast::Expr *             visit( const ast::LogicalExpr          * ) override final;
         const ast::Expr *             visit( const ast::ConditionalExpr      * ) override final;

src/AST/Pass.impl.hpp

@@ -1452 +1452 @@
 
 //--------------------------------------------------------------------------
+// EnumPosExpr
+template< typename core_t>
+const ast::Expr * ast::Pass< core_t >::visit( const ast::EnumPosExpr * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &EnumPosExpr::type );
+                maybe_accept( node, &EnumPosExpr::expr );
+        }
+
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
 // LogicalExpr
 template< typename core_t >

src/AST/Print.cpp

@@ -1183 +1183 @@
         }
 
+        virtual const ast::Expr * visit( const ast::EnumPosExpr * node ) override final {
+                os << "Enum Position Expression on: ";
+                ++indent;
+                safe_print( node->type );
+                --indent;
+                postprint( node );
+                return node;
+        }
+
         virtual const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
                 os << "Short-circuited operation (" << (node->isAnd ? "and" : "or") << ") on: ";

src/AST/Visitor.hpp

@@ -79 +79 @@
     virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::OffsetPackExpr       * ) = 0;
+    virtual const ast::Expr *             visit( const ast::EnumPosExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::LogicalExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::ConditionalExpr      * ) = 0;

src/CodeGen/CodeGenerator.cpp

@@ -778 +778 @@
 }
 
+void CodeGenerator::postvisit( ast::EnumPosExpr const * expr ) {
+        assertf( !options.genC, "EnumPosExpr should not reach code generation." );
+        output << "__CFA_enumeration_pos(" << genType( expr->type, "", options ) << ")";
+}
+
 void CodeGenerator::postvisit( ast::LogicalExpr const * expr ) {
         extension( expr );

src/CodeGen/CodeGenerator.hpp

@@ -76 +76 @@
         void postvisit( ast::OffsetPackExpr const * );
         void postvisit( ast::LogicalExpr const * );
+        void postvisit( ast::EnumPosExpr const * );
         void postvisit( ast::ConditionalExpr const * );
         void postvisit( ast::CommaExpr const * );

src/Common/CodeLocationTools.cpp

@@ -158 +158 @@
     macro(OffsetPackExpr, Expr) \
     macro(LogicalExpr, Expr) \
+        macro(EnumPosExpr, Expr) \
     macro(ConditionalExpr, Expr) \
     macro(CommaExpr, Expr) \

src/GenPoly/Box.cpp

@@ -1580 +1580 @@
         ast::Expr const * postvisit( ast::OffsetPackExpr const * expr );
 
+        ast::Expr const * postvisit( ast::EnumPosExpr const * expr );
+
         void beginScope();
         void endScope();
@@ -1950 +1952 @@
 
         return new ast::VariableExpr( expr->location, offsetArray );
+}
+
+// TODO 
+ast::Expr const * PolyGenericCalculator::postvisit( ast::EnumPosExpr const * expr ) {
+        return expr;
 }
 

src/InitTweak/InitTweak.cc

@@ -271 +271 @@
                 void previsit( const ast::OffsetofExpr * ) {}
                 void previsit( const ast::OffsetPackExpr * ) {}
+                void previsit( const ast::EnumPosExpr * ) {}
                 void previsit( const ast::CommaExpr * ) {}
                 void previsit( const ast::LogicalExpr * ) {}

src/Parser/ExpressionNode.cc

@@ -690 +690 @@
 } // build_unary_val
 
+ast::Expr * build_enum_pos_expr( const CodeLocation & location, ast::Expr * expr_node ) {
+        // return nullptr
+        return new ast::EnumPosExpr( location, std::move( expr_node ) );
+}
+
 ast::Expr * build_binary_val( const CodeLocation & location,
                 OperKinds op,

src/Parser/ExpressionNode.h

@@ -83 +83 @@
 ast::Expr * build_func( const CodeLocation &, ExpressionNode * function, ExpressionNode * expr_node );
 ast::Expr * build_compoundLiteral( const CodeLocation &, DeclarationNode * decl_node, InitializerNode * kids );
+
+ast::Expr * build_enum_pos_expr( const CodeLocation &, ast::Expr * expr_node );

src/ResolvExpr/CandidateFinder.cpp

@@ -52 +52 @@
 #include "Common/Stats/Counter.h"
 
+#include "AST/Inspect.hpp"             // for getFunctionName
+
 #define PRINT( text ) if ( resolvep ) { text }
 
@@ -656 +658 @@
                 void postvisit( const ast::OffsetofExpr * offsetofExpr );
                 void postvisit( const ast::OffsetPackExpr * offsetPackExpr );
+                void postvisit( const ast::EnumPosExpr * enumPosExpr );
                 void postvisit( const ast::LogicalExpr * logicalExpr );
                 void postvisit( const ast::ConditionalExpr * conditionalExpr );
@@ -1471 +1474 @@
         void Finder::postvisit( const ast::OffsetPackExpr * offsetPackExpr ) {
                 addCandidate( offsetPackExpr, tenv );
+        }
+
+        void Finder::postvisit( const ast::EnumPosExpr * enumPosExpr ) {
+                CandidateFinder finder( context, tenv );
+                finder.find( enumPosExpr->expr );
+                CandidateList winners = findMinCost( finder.candidates );
+                if ( winners.size() != 1 ) SemanticError( enumPosExpr->expr.get(), "Ambiguous expression in position. ");
+                CandidateRef & choice = winners.front();
+                auto refExpr = referenceToRvalueConversion( choice->expr, choice->cost );
+                auto refResult = (refExpr->result).as<ast::EnumInstType>();
+                if ( !refResult ) {
+                        SemanticError( refExpr, "Position for Non enum type is not supported" );
+                }
+                // determineEnumPosConstant( enumPosExpr, refResult );
+
+                const ast::NameExpr * const nameExpr = enumPosExpr->expr.strict_as<ast::NameExpr>();
+                const ast::EnumDecl * base = refResult->base;
+                if ( !base ) {
+                        SemanticError( enumPosExpr, "Cannot be reference to a defined enumeration type" );
+                }
+                auto it = std::find_if( std::begin( base->members ), std::end( base->members ), 
+                        [nameExpr]( ast::ptr<ast::Decl> decl ) { return decl->name == nameExpr->name; } );
+                unsigned position = it - base->members.begin();
+                addCandidate( ast::ConstantExpr::from_int( enumPosExpr->location, position ), tenv );
         }
 

src/ResolvExpr/Resolver.cc

@@ -420 +420 @@
                 const ast::ConstructorInit * previsit( const ast::ConstructorInit * );
 
+                const ast::EnumPosExpr *         previsit( const ast::EnumPosExpr * );
+
                 void resolveWithExprs(std::vector<ast::ptr<ast::Expr>> & exprs, std::list<ast::ptr<ast::Stmt>> & stmtsToAdd);
 
@@ -1239 +1241 @@
         }
 
+        const ast::EnumPosExpr * Resolver::previsit( const ast::EnumPosExpr * enumPos ) {
+                visitor->maybe_accept( enumPos, &ast::EnumPosExpr::expr );
+                return enumPos;
+        }
+
         // suppress error on autogen functions and mark invalid autogen as deleted.
         bool Resolver::on_error(ast::ptr<ast::Decl> & decl) {

src/Validate/Autogen.cpp

@@ -186 +186 @@
                 // could possibly use a new linkage type. For now we just make the
                 // basic ones intrinsic to code-gen them as C assignments.
-                const auto & real_type = decl->base;
-                const auto & basic = real_type.as<ast::BasicType>();
-                if(!real_type || (basic && basic->isInteger())) proto_linkage = ast::Linkage::Intrinsic;
+                // const auto & real_type = decl->base;
+                // const auto & basic = real_type.as<ast::BasicType>();
+
+                // if(!real_type || (basic && basic->isInteger())) proto_linkage = ast::Linkage::Intrinsic;
+
+                // Turns other enumeration type into Intrinstic as well to temporarily fix the recursive 
+                // construction bug
+                proto_linkage = ast::Linkage::Intrinsic;
         }
 
@@ -742 +747 @@
                         }
                 );
+                // auto fname = ast::getFunctionName( callExpr );
+                // if (fname == "posE" ) {
+                //      std::cerr << "Found posE autogen" << std::endl;
+                // }
                 functionDecl->stmts = new ast::CompoundStmt( location,
                         { new ast::ExprStmt( location, callExpr ) }
@@ -792 +801 @@
 }
 
+struct PseudoFuncGenerateRoutine final :
+                public ast::WithDeclsToAdd<>,
+                public ast::WithShortCircuiting {
+        void previsit( const ast::EnumDecl * enumDecl );
+};
+
+void PseudoFuncGenerateRoutine::previsit( const ast::EnumDecl * enumDecl ) {
+        const CodeLocation& location = enumDecl->location;
+        if ( enumDecl->members.size() == 0 || !enumDecl->base || enumDecl->name == "" ) return;
+
+        std::vector<ast::ptr<ast::Init>> inits;
+        std::vector<ast::ptr<ast::Init>> labels;
+        for ( const ast::Decl * mem: enumDecl->members ) {
+                auto memAsObjectDecl = dynamic_cast< const ast::ObjectDecl * >( mem );
+                inits.emplace_back( memAsObjectDecl->init );
+                labels.emplace_back( new ast::SingleInit( 
+                        location, ast::ConstantExpr::from_string(location, mem->name) ) );
+        }
+        auto init = new ast::ListInit( location, std::move( inits ) );
+        auto label_strings = new ast::ListInit( location, std::move(labels) );
+        auto values = new ast::ObjectDecl( 
+                location,
+                "__enum_values_"+enumDecl->name,
+                new ast::ArrayType(
+                        // new ast::PointerType( new ast::BasicType{ ast::BasicType::Char} ),
+                        enumDecl->base,
+                        ast::ConstantExpr::from_int( location, enumDecl->members.size() ), 
+                        ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim
+                )
+                ,init
+                ,
+                ast::Storage::Static,
+                ast::Linkage::AutoGen
+        );
+        auto label_arr = new ast::ObjectDecl(
+                location,
+                "__enum_labels_"+enumDecl->name,
+                new ast::ArrayType(
+                        new ast::PointerType( new ast::BasicType{ ast::BasicType::Char} ),
+                        ast::ConstantExpr::from_int( location, enumDecl->members.size() ), 
+                        ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim
+                ),
+                label_strings,
+                ast::Storage::Static,
+                ast::Linkage::AutoGen
+        );
+
+        declsToAddAfter.push_back( values );
+        declsToAddAfter.push_back( label_arr );
+}
+
 } // namespace
 
 void autogenerateRoutines( ast::TranslationUnit & translationUnit ) {
         ast::Pass<AutogenerateRoutines>::run( translationUnit );
+        // ast::Pass<PseudoFuncGenerateRoutine>::run( translationUnit );
 }
 

src/Validate/module.mk

@@ -52 +52 @@
         Validate/ReturnCheck.hpp \
         Validate/VerifyCtorDtorAssign.cpp \
-        Validate/VerifyCtorDtorAssign.hpp
+        Validate/VerifyCtorDtorAssign.hpp \
+        Validate/ReplacePseudoFunc.cpp \
+        Validate/ReplacePseudoFunc.hpp
 
 SRCDEMANGLE += $(SRC_VALIDATE)

src/main.cc

@@ -82 +82 @@
 #include "Validate/ReturnCheck.hpp"         // for checkReturnStatements
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
+#include "Validate/ReplacePseudoFunc.hpp"
 #include "Virtual/ExpandCasts.h"            // for expandCasts
 #include "Virtual/VirtualDtor.hpp"          // for implementVirtDtors
@@ -287 +288 @@
                         assertf( extras, "cannot open extras.cf\n" );
                         parse( extras, ast::Linkage::BuiltinC );
-
                         if ( ! libcfap ) {
                                 // read the prelude in, if not generating the cfa library
@@ -322 +322 @@
                 PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );
                 PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+
                 PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
                 PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
@@ -381 +382 @@
                 PASS( "Resolve", ResolvExpr::resolve, transUnit );
                 DUMP( exprp, std::move( transUnit ) );
+                PASS( "Replace Pseudo Func", Validate::replacePseudoFunc, transUnit );
 
                 PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() );