Changeset afc1045

Timestamp:

Apr 5, 2016, 3:31:09 PM (9 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

d75038c

Parents:

b3f9a0cb

Message:

Hoist OffsetPackExpr? to top level expression

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (3 diffs)
• GenPoly/ScopedSet.h (added)
• InitTweak/InitModel.h (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• Tuples/FlattenTuple.cc (modified) (1 diff)
• Tuples/FlattenTuple.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -455 +455 @@
 
         void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) {
-                assert( false );
+                assert( false && "UntypedOffsetofExpr should not reach code generation" );
         }
 
@@ -464 +464 @@
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
+        }
+
+        void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) {
+                assert( false && "OffsetPackExpr should not reach code generation" );
         }
   

src/CodeGen/CodeGenerator.h

@@ -65 +65 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( LogicalExpr *logicalExpr );
                 virtual void visit( ConditionalExpr *conditionalExpr );

src/GenPoly/Box.cc

@@ -214 +214 @@
                 };
 
-                class OffsetPackExpr;  // forward declaration so that it can be mutated by Pass2
-
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
@@ -232 +230 @@
                         virtual Expression *mutate( AlignofExpr *alignofExpr );
                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
-                                Expression *mutate( OffsetPackExpr *offsetPackExpr );
+                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
 
                         virtual void doBeginScope();
@@ -248 +246 @@
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
-                };
-
-                /// Special internal expression for offset arrays inserted by Pass1 and replaced by Pass2
-                class OffsetPackExpr : public Expression {
-                public:
-                        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 ) : Expression( aname_ ), type( type_ ) {
-                                        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
-                        }
-                        
-                        OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
-                        virtual ~OffsetPackExpr() { delete type; }
-
-                        StructInstType *get_type() const { return type; }
-                        void set_type( StructInstType *newValue ) { type = newValue; }
-
-                        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
-                        virtual void accept( Visitor &v ) { /* do nothing */ }
-                        virtual Expression *acceptMutator( Mutator &m ) {
-                                // only act if the mutator is a Pass2, which knows about this class
-                                if ( Pass2 *m2 = dynamic_cast< Pass2* >( &m ) ) {
-                                        return m2->mutate( this );
-                                } else {
-                                        return this;
-                                }
-                        }
-
-                        virtual void print( std::ostream &os, int indent = 0 ) const {
-                                os << std::string( indent, ' ' ) << "Offset pack expression on ";
-
-                                if ( type ) {
-                                        type->print(os, indent + 2);
-                                } else {
-                                        os << "<NULL>";
-                                }
-
-                                os << std::endl;
-                                Expression::print( os, indent );
-                        }
-                        
-                private:
-                        StructInstType *type;
                 };
 

src/InitTweak/InitModel.h

@@ -75 +75 @@
                         void visit( UntypedOffsetofExpr * ) { throw 0; }
                         void visit( OffsetofExpr * ) { throw 0; }
+                        void visit( OffsetPackExpr * ) { throw 0; }
                         void visit( AttrExpr * ) { throw 0; }
                         void visit( LogicalExpr * ) { throw 0; }

src/ResolvExpr/AlternativeFinder.cc

@@ -848 +848 @@
         }
 
+        void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
+                alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
+        }
+
         void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
                 // assume no polymorphism

src/ResolvExpr/AlternativeFinder.h

@@ -59 +59 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Indexer.cc

@@ -344 +344 @@
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
+        }
+
+        void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
+                maybeAccept( offsetPackExpr->get_type(), *this );
         }
 

src/SymTab/Indexer.h

@@ -59 +59 @@
                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
                 virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SynTree/Expression.cc

@@ -222 +222 @@
 }
 
+OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
+
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+
+OffsetPackExpr::~OffsetPackExpr() { delete type; }
+
+void OffsetPackExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Offset pack expression on ";
+
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
 AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {

src/SynTree/Expression.h

@@ -362 +362 @@
 };
 
+/// Expression representing a pack of field-offsets for a generic type
+class OffsetPackExpr : public Expression {
+public:
+        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
+        OffsetPackExpr( const OffsetPackExpr &other );
+        virtual ~OffsetPackExpr();
+
+        StructInstType *get_type() const { return type; }
+        void set_type( StructInstType *newValue ) { type = newValue; }
+
+        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+
+private:
+        StructInstType *type;
+};
+
 /// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {

src/SynTree/Mutator.cc

@@ -274 +274 @@
 }
 
+Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
+        mutateAll( offsetPackExpr->get_results(), *this );
+        offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
+        return offsetPackExpr;
+}
+
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         mutateAll( attrExpr->get_results(), *this );

src/SynTree/Mutator.h

@@ -67 +67 @@
         virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr );
         virtual Expression* mutate( OffsetofExpr *offsetofExpr );
+        virtual Expression* mutate( OffsetPackExpr *offsetPackExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );

src/SynTree/SynTree.h

@@ -72 +72 @@
 class UntypedOffsetofExpr;
 class OffsetofExpr;
+class OffsetPackExpr;
 class AttrExpr;
 class LogicalExpr;

src/SynTree/Visitor.cc

@@ -230 +230 @@
 }
 
+void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
+        acceptAll( offsetPackExpr->get_results(), *this );
+        maybeAccept( offsetPackExpr->get_type(), *this );
+}
+
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );

src/SynTree/Visitor.h

@@ -67 +67 @@
         virtual void visit( UntypedOffsetofExpr *offsetofExpr );
         virtual void visit( OffsetofExpr *offsetofExpr );
+        virtual void visit( OffsetPackExpr *offsetPackExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );

src/Tuples/FlattenTuple.cc

@@ -49 +49 @@
         void FlattenTuple::CollectArgs::visit( UntypedOffsetofExpr *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( OffsetofExpr        *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
+        void FlattenTuple::CollectArgs::visit( OffsetPackExpr      *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( AttrExpr            *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( LogicalExpr         *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }

src/Tuples/FlattenTuple.h

@@ -45 +45 @@
                         virtual void visit( UntypedOffsetofExpr * );
                         virtual void visit( OffsetofExpr * );
+                        virtual void visit( OffsetPackExpr * );
                         virtual void visit( AttrExpr * );
                         virtual void visit( LogicalExpr * );