Changeset f135b50

Timestamp:

Feb 28, 2022, 3:41:44 AM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

786c438

Parents:

a8ef59e

Message:

The compiler is now trying to pass the value of enum const to code gen; but it won't work cause we must be able to evaluate the const_expr in compiler time. It is not currently passed as a Expression but won't be able to evaluate at compile time

Location:

src

Files:

• AST/Convert.cpp (modified) (7 diffs)
• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/GenType.cc (modified) (1 diff)
• Common/Eval.cc (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (4 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (2 diffs)
• Parser/TypeData.h (modified) (1 diff)
• Parser/parser.yy (modified) (3 diffs)
• SymTab/Demangle.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (3 diffs)
• SynTree/Visitor.h (modified) (2 diffs)

src/AST/Convert.cpp

@@ -276 +276 @@
                 decl->parent = get<AggregateDecl>().accept1( node->parent );
                 declPostamble( decl, node );
-                return nullptr;
+                return nullptr; // ??
         }
 
@@ -305 +305 @@
         }
 
-        const ast::Decl * visit( const ast::EnumDecl * node ) override final {
+        const ast::Decl * visit( const ast::EnumDecl * node ) override final { // Marker: what is this for? 
+        // Called in ConverterNewToOld
                 if ( inCache( node ) ) return nullptr;
                 auto decl = new EnumDecl(
@@ -312 +313 @@
                         LinkageSpec::Spec( node->linkage.val )
                 );
-                return aggregatePostamble( decl, node );
+                return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
         }
 
@@ -1495 +1496 @@
                 getAccept1< ast::type, decltype( old->child ) >( old->child )
 
+#       define GET_ACCEPT_E(child, type) \
+                getAccept1< ast::type, decltype( old->base ) >( old->base )
+
         template<typename NewT, typename OldC>
         std::vector< ast::ptr<NewT> > getAcceptV( const OldC& old ) {
@@ -1710 +1714 @@
         }
 
+        // Marker
+        // Convert SynTree::EnumDecl to AST::EnumDecl
         virtual void visit( const EnumDecl * old ) override final {
                 if ( inCache( old ) ) return;
@@ -1716 +1722 @@
                         old->name,
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->linkage.val }
+                        { old->linkage.val },
+                        old->base? GET_ACCEPT_E(base, Type) : nullptr,
+                        old->enumValues
                 );
                 cache.emplace( old, decl );
@@ -1726 +1734 @@
                 decl->uniqueId   = old->uniqueId;
                 decl->storage    = { old->storageClasses.val };
-
                 this->node = decl;
         }

src/AST/Decl.cpp

@@ -133 +133 @@
 
         auto it = enumValues.find( enumerator->name );
+        
         if ( it != enumValues.end() ) {
-                value = it->second;
+                        
+                // Handle typed enum by casting the value in (C++) compiler
+                if ( base ) { // A typed enum
+                        if ( const BasicType * bt = dynamic_cast<const BasicType *>(base) ) {
+                                switch( bt->kind ) {
+                                        case BasicType::Kind::Bool:     value = (bool) it->second; break;
+                                        case BasicType::Kind::Char: value = (char) it->second; break;
+                                        case BasicType::Kind::SignedChar: value = (signed char) it->second; break;
+                                        case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break;
+                                        case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break;
+                                        case BasicType::Kind::SignedInt: value = (signed int) it->second; break;
+                                        case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break;
+                                        case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break;
+                                        case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break;
+                                        case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break;
+                                        case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; 
+                                        // TODO: value should be able to handle long long unsigned int
+
+                                        default:
+                                        value = it->second;
+                                }
+                        }
+                } else {
+                        value = it->second;
+                }
+
                 return true;
         }

src/AST/Decl.hpp

@@ -302 +302 @@
 class EnumDecl final : public AggregateDecl {
 public:
+        Type * base;
+
         EnumDecl( const CodeLocation& loc, const std::string& name,
-                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
-        : AggregateDecl( loc, name, std::move(attrs), linkage ), enumValues() {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type * base = nullptr,
+                 std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {}
 
         /// gets the integer value for this enumerator, returning true iff value found
+        // Maybe it is not used in producing the enum value
         bool valueOf( const Decl * enumerator, long long& value ) const;
 

src/CodeGen/CodeGenerator.cc

@@ -274 +274 @@
         void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
                 extension( enumDecl );
-                output << "enum ";
+                output << "enum /* Marker CodeGenerator::EnumDecl */ ";
                 genAttributes( enumDecl->get_attributes() );
 
@@ -291 +291 @@
                                 if ( obj->get_init() ) {
                                         output << " = ";
+                                        // In progress
                                         obj->get_init()->accept( *visitor );
                                 } // if

src/CodeGen/GenType.cc

@@ -254 +254 @@
         void GenType::postvisit( EnumInstType * enumInst ) {
                 typeString = enumInst->name + " " + typeString;
-                if ( options.genC ) typeString = "enum " + typeString;
+                if ( options.genC ) typeString = "enum /* Marker GenType::EnumInstType */ " + typeString;
                 handleQualifiers( enumInst );
         }

src/Common/Eval.cc

@@ -112 +112 @@
         }
 
-        void postvisit( const ast::VariableExpr * expr ) {
+        void postvisit( const ast::VariableExpr * expr ) { // No hit
                 if ( const ast::EnumInstType * inst = dynamic_cast<const ast::EnumInstType *>(expr->result.get()) ) {
                         if ( const ast::EnumDecl * decl = inst->base ) {

src/Common/PassVisitor.impl.h

@@ -754 +754 @@
 
         // unlike structs, traits, and unions, enums inject their members into the global scope
+        if ( node->base ) maybeAccept_impl( node->base, *this ); // Need this? Maybe not?
         maybeAccept_impl( node->parameters, *this );
         maybeAccept_impl( node->members   , *this );

src/Parser/DeclarationNode.cc

@@ -78 +78 @@
         delete variable.initializer;
 
-        delete type;
+//      delete type;
         delete bitfieldWidth;
 
@@ -253 +253 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool ) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
@@ -272 +272 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
+DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker
         DeclarationNode * newnode = newName( name );
         newnode->enumeratorValue.reset( constant );
@@ -667 +667 @@
 }
 
+DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
+        if ( o && o -> type)  {
+                type->base= o->type;
+        }
+        delete o;
+        return this;
+}
+
 DeclarationNode * DeclarationNode::addTypedef() {
         TypeData * newtype = new TypeData( TypeData::Symbolic );

src/Parser/ParseNode.h

@@ -265 +265 @@
         DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
+        DeclarationNode * addEnumBase( DeclarationNode * );
         DeclarationNode * addAssertions( DeclarationNode * );
         DeclarationNode * addName( std::string * );

src/Parser/StatementNode.cc

@@ -366 +366 @@
 } // maybe_build_compound
 
+// Question
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         list< Expression * > out, in;

src/Parser/TypeData.cc

@@ -918 +918 @@
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
-        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage );
-        buildList( td->enumeration.constants, ret->get_members() );
+        Type* baseType = td->base ? typebuild(td->base) : nullptr;
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
+        buildList( td->enumeration.constants, ret->get_members() ); // enumConstant is both a node and a list
         list< Declaration * >::iterator members = ret->get_members().begin();
-        for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
+        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
@@ -927 +928 @@
                 } // if
         } // for
-        ret->set_body( td->enumeration.body );
+        ret->set_body( td->enumeration.body ); // Boolean; if it has body
         return ret;
 } // buildEnum

src/Parser/TypeData.h

@@ -132 +132 @@
                                                  Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
+Declaration * addEnumBase( Declaration *, const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );
 

src/Parser/parser.yy

@@ -2292 +2292 @@
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         // SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
-                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
+
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
@@ -2301 +2303 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2307 +2310 @@
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6->name );
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | enum_type_nobody

src/SymTab/Demangle.cc

@@ -252 +252 @@
 
         void GenType::postvisit( EnumInstType * enumInst ) {
-                typeString = "enum " + enumInst->name + " " + typeString;
+                typeString = "enum /* Marker demangle::EnumInstType */ " + enumInst->name + " " + typeString;
                 handleQualifiers( enumInst );
         }

src/SynTree/Declaration.h

@@ -119 +119 @@
   public:
         Type * type;
-        Initializer * init;
+        Initializer * init; // For Enum, the init is a pointer that contain the enum value; see Parser::TypeData::buildEnum
         Expression * bitfieldWidth;
 
@@ -335 +335 @@
         typedef AggregateDecl Parent;
   public:
-        EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+        EnumDecl( const std::string & name,
+         const std::list< Attribute * > & attributes = std::list< class Attribute * >(),
+          LinkageSpec::Spec linkage = LinkageSpec::Cforall,
+          Type * baseType = nullptr ) : Parent( name, attributes, linkage ) , base( baseType ){}
         EnumDecl( const EnumDecl & other ) : Parent( other ) {}
 
@@ -344 +347 @@
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-  private:
+        Type * base;
         std::unordered_map< std::string, long long int > enumValues;
+  private:
+        // std::unordered_map< std::string, long long int > enumValues;
         virtual const char * typeString() const override;
 };

src/SynTree/Visitor.h

@@ -35 +35 @@
         virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
         virtual void visit( const UnionDecl * aggregateDecl ) = 0;
-        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
+        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); } // Marker 1
         virtual void visit( const EnumDecl * aggregateDecl ) = 0;
         virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
@@ -190 +190 @@
         virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
         virtual void visit( const UnionInstType * aggregateUseType ) = 0;
-        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
+        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); } // Marker 2
         virtual void visit( const EnumInstType * aggregateUseType ) = 0;
         virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }