Changeset c935c3a for src/GenPoly/Box.cc

Timestamp:

Sep 13, 2017, 3:03:32 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

ed235b6

Parents:

b2e2e34 (diff), 982832e (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

File:

• src/GenPoly/Box.cc (modified) (25 diffs)

src/GenPoly/Box.cc

@@ -15 +15 @@
 
 #include <algorithm>                     // for mismatch
-#include <cassert>                       // for assert, safe_dynamic_cast
+#include <cassert>                       // for assert, strict_dynamic_cast
 #include <iostream>                      // for operator<<, stringstream
 #include <list>                          // for list, list<>::iterator, _Lis...
@@ -27 +27 @@
 
 #include "CodeGen/OperatorTable.h"
+#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/ScopedMap.h"            // for ScopedMap, ScopedMap<>::iter...
 #include "Common/SemanticError.h"        // for SemanticError
@@ -157 +158 @@
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator final : public PolyMutator {
+                class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
-                        typedef PolyMutator Parent;
-                        using Parent::mutate;
-
                         PolyGenericCalculator();
 
-                        template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl, Type *type );
-                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
-                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
-                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
-                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
-                        virtual Statement *mutate( DeclStmt *declStmt ) override;
-                        virtual Type *mutate( PointerType *pointerType ) override;
-                        virtual Type *mutate( FunctionType *funcType ) override;
-                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
-                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
-                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
-                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
-                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
-
-                        virtual void doBeginScope() override;
-                        virtual void doEndScope() override;
+                        void premutate( ObjectDecl *objectDecl );
+                        void premutate( FunctionDecl *functionDecl );
+                        void premutate( TypedefDecl *objectDecl );
+                        void premutate( TypeDecl *objectDecl );
+                        Declaration * postmutate( TypeDecl *TraitDecl );
+                        void premutate( PointerType *pointerType );
+                        void premutate( FunctionType *funcType );
+                        void premutate( DeclStmt *declStmt );
+                        Expression *postmutate( MemberExpr *memberExpr );
+                        Expression *postmutate( SizeofExpr *sizeofExpr );
+                        Expression *postmutate( AlignofExpr *alignofExpr );
+                        Expression *postmutate( OffsetofExpr *offsetofExpr );
+                        Expression *postmutate( OffsetPackExpr *offsetPackExpr );
+
+                        void beginScope();
+                        void endScope();
 
                 private:
@@ -194 +191 @@
                         /// Exits the type-variable scope
                         void endTypeScope();
+                        /// Enters a new scope for knowLayouts and knownOffsets and queues exit calls
+                        void beginGenericScope();
 
                         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
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
+                        TyVarMap scopeTyVars;
                 };
 
@@ -250 +250 @@
                 Pass1 pass1;
                 Pass2 pass2;
-                PolyGenericCalculator polyCalculator;
+                PassVisitor<PolyGenericCalculator> polyCalculator;
                 Pass3 pass3;
 
@@ -256 +256 @@
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
+                mutateAll( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -555 +555 @@
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Mutator::mutate( typeDecl );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
                 }
 
@@ -762 +762 @@
                                 } else if ( arg->get_result()->get_lvalue() ) {
                                         // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                        //              return;
+                                        //      }
+                                        // }
                                         arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
@@ -1299 +1305 @@
 
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1353 +1359 @@
                                 return handleDecl( typeDecl );
                         } else {
-                                return Parent::mutate( typeDecl );
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
                         }
                 }
@@ -1378 +1384 @@
                         // move polymorphic return type to parameter list
                         if ( isDynRet( funcType ) ) {
-                                ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
+                                ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
                                 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
                                 funcType->get_parameters().push_front( ret );
@@ -1466 +1472 @@
 
                 PolyGenericCalculator::PolyGenericCalculator()
-                        : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
 
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
-                        scopeTyVars.beginScope();
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( ty, scopeTyVars );
                 }
 
-                void PolyGenericCalculator::endTypeScope() {
-                        scopeTyVars.endScope();
-                }
-
-                template< typename DeclClass >
-                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
-                        beginTypeScope( type );
-                        // knownLayouts.beginScope();
-                        // knownOffsets.beginScope();
-
-                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
-
-                        // knownOffsets.endScope();
-                        // knownLayouts.endScope();
-                        endTypeScope();
-                        return ret;
-                }
-
-                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
-                }
-
-                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
-                        knownLayouts.beginScope();
-                        knownOffsets.beginScope();
-
-                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
-                        knownOffsets.endScope();
-                        knownLayouts.endScope();
-                        return decl;
-                }
-
-                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl, typedefDecl->get_base() );
-                }
-
-                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
+                void PolyGenericCalculator::beginGenericScope() {
+                        GuardScope( *this );
+                }
+
+                void PolyGenericCalculator::premutate( ObjectDecl *objectDecl ) {
+                        beginTypeScope( objectDecl->get_type() );
+                }
+
+                void PolyGenericCalculator::premutate( FunctionDecl *functionDecl ) {
+                        beginGenericScope();
+
+                        beginTypeScope( functionDecl->get_functionType() );
+                }
+
+                void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
+                        beginTypeScope( typedefDecl->get_base() );
+                }
+
+                void PolyGenericCalculator::premutate( TypeDecl * typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Parent::mutate( typeDecl );
-                }
-
-                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
+                }
+
+                Declaration * PolyGenericCalculator::postmutate( TypeDecl *typeDecl ) {
+                        if ( Type * base = typeDecl->base ) {
+                                // add size/align variables for opaque type declarations
+                                TypeInstType inst( Type::Qualifiers(), typeDecl->name, typeDecl );
+                                std::string typeName = mangleType( &inst );
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                ObjectDecl * sizeDecl = ObjectDecl::newObject( sizeofName( typeName ), layoutType, new SingleInit( new SizeofExpr( base->clone() ) ) );
+                                ObjectDecl * alignDecl = ObjectDecl::newObject( alignofName( typeName ), layoutType->clone(), new SingleInit( new AlignofExpr( base->clone() ) ) );
+
+                                // ensure that the initializing sizeof/alignof exprs are properly mutated
+                                sizeDecl->acceptMutator( *visitor );
+                                alignDecl->acceptMutator( *visitor );
+
+                                // can't use makeVar, because it inserts into stmtsToAdd and TypeDecls can occur at global scope
+                                declsToAddAfter.push_back( alignDecl );
+                                // replace with sizeDecl
+                                return sizeDecl;
+                        }
+                        return typeDecl;
+                }
+
+                void PolyGenericCalculator::premutate( PointerType *pointerType ) {
                         beginTypeScope( pointerType );
-
-                        Type *ret = Parent::mutate( pointerType );
-
-                        endTypeScope();
-                        return ret;
-                }
-
-                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
+                }
+
+                void PolyGenericCalculator::premutate( FunctionType *funcType ) {
                         beginTypeScope( funcType );
 
@@ -1534 +1538 @@
                                 }
                         }
-
-                        Type *ret = Parent::mutate( funcType );
-
-                        endTypeScope();
-                        return ret;
-                }
-
-                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
+                }
+
+                void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( findGeneric( objectDecl->get_type() ) ) {
@@ -1550 +1549 @@
                                                 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
                                                 true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
 
                                         delete objectDecl->get_init();
@@ -1556 +1555 @@
                                 }
                         }
-                        return Parent::mutate( declStmt );
                 }
 
@@ -1583 +1581 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
-                        // mutate, exiting early if no longer MemberExpr
-                        Expression *expr = Parent::mutate( memberExpr );
-                        memberExpr = dynamic_cast< MemberExpr* >( expr );
-                        if ( ! memberExpr ) return expr;
-
+                Expression *PolyGenericCalculator::postmutate( MemberExpr *memberExpr ) {
                         // only mutate member expressions for polymorphic types
                         int tyDepth;
@@ -1635 +1628 @@
                 ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
                         ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
-                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -1714 +1707 @@
                                         addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
                                 }
 
@@ -1740 +1733 @@
                                 addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
 
                                 return true;
@@ -1748 +1741 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
+                Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
                         Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1758 +1751 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
+                Expression *PolyGenericCalculator::postmutate( AlignofExpr *alignofExpr ) {
                         Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
                         if ( findGeneric( ty ) ) {
@@ -1768 +1761 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
-                        // mutate, exiting early if no longer OffsetofExpr
-                        Expression *expr = Parent::mutate( offsetofExpr );
-                        offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
-                        if ( ! offsetofExpr ) return expr;
-
+                Expression *PolyGenericCalculator::postmutate( OffsetofExpr *offsetofExpr ) {
                         // only mutate expressions for polymorphic structs/unions
                         Type *ty = offsetofExpr->get_type();
@@ -1793 +1781 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
+                Expression *PolyGenericCalculator::postmutate( OffsetPackExpr *offsetPackExpr ) {
                         StructInstType *ty = offsetPackExpr->get_type();
 
@@ -1832 +1820 @@
                 }
 
-                void PolyGenericCalculator::doBeginScope() {
+                void PolyGenericCalculator::beginScope() {
                         knownLayouts.beginScope();
                         knownOffsets.beginScope();
                 }
 
-                void PolyGenericCalculator::doEndScope() {
+                void PolyGenericCalculator::endScope() {
                         knownLayouts.endScope();
                         knownOffsets.endScope();
@@ -1894 +1882 @@
 
                         addToTyVarMap( typeDecl, scopeTyVars );
-                        return Mutator::mutate( typeDecl );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
                 }