Changeset b95fe40

Timestamp:

Nov 22, 2017, 3:40:12 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

7e4c4f4

Parents:

98a249fb

Message:

Add casts to dtype-static member expressions to prevent loss of type information [fixes #42] [fixes #59]

Location:

src

Files:

• GenPoly/InstantiateGeneric.cc (modified) (4 diffs)
• SymTab/Autogen.h (modified) (6 diffs)
• SymTab/Validate.cc (modified) (5 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -27 +27 @@
 #include "Common/utility.h"            // for deleteAll, cloneAll
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
+#include "ResolvExpr/typeops.h"
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
 #include "ScrubTyVars.h"               // for ScrubTyVars
@@ -151 +152 @@
                 return gt;
         }
+
+        /// Add cast to dtype-static member expressions so that type information is not lost in GenericInstantiator
+        struct FixDtypeStatic final {
+                Expression * postmutate( MemberExpr * memberExpr );
+
+                template<typename AggrInst>
+                Expression * fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr );
+        };
 
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
@@ -198 +207 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
+                PassVisitor<FixDtypeStatic> fixer;
                 PassVisitor<GenericInstantiator> instantiator;
+
+                mutateAll( translationUnit, fixer );
                 mutateAll( translationUnit, instantiator );
+        }
+
+        bool isDtypeStatic( const std::list< TypeDecl* >& baseParams ) {
+                return std::all_of( baseParams.begin(), baseParams.end(), []( TypeDecl * td ) { return ! td->isComplete(); } );
         }
 
@@ -479 +495 @@
         }
 
+        template< typename AggrInst >
+        Expression * FixDtypeStatic::fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr ) {
+                // need to cast dtype-static member expressions to their actual type before that type is erased.
+                auto & baseParams = *inst->get_baseParameters();
+                if ( isDtypeStatic( baseParams ) ) {
+                        if ( ! ResolvExpr::typesCompatible( memberExpr->result, memberExpr->member->get_type(), SymTab::Indexer() ) ) {
+                                // type of member and type of expression differ, so add cast to actual type
+                                return new CastExpr( memberExpr, memberExpr->result->clone() );
+                        }
+                }
+                return memberExpr;
+        }
+
+        Expression * FixDtypeStatic::postmutate( MemberExpr * memberExpr ) {
+                Type * aggrType = memberExpr->aggregate->result;
+                if ( isGenericType( aggrType ) ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( aggrType ) ) {
+                                return fixMemberExpr( inst, memberExpr );
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( aggrType ) ) {
+                                return fixMemberExpr( inst, memberExpr );
+                        }
+                }
+                return memberExpr;
+        }
+
 } // namespace GenPoly
 

src/SymTab/Autogen.h

@@ -56 +56 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -68 +68 @@
                         fname = "?=?";
                         dstParam = new AddressExpr( dstParam );
-                        addCast = false;
+                        addCast = nullptr;
                         isReferenceCtorDtor = true;
                 }
@@ -83 +83 @@
                         // remove lvalue as a qualifier, this can change to
                         //   type->get_qualifiers() = Type::Qualifiers();
-                        assert( type );
-                        Type * castType = type->clone();
+                        Type * castType = addCast->clone();
                         castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
@@ -115 +114 @@
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
                 // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->get_dimension() ) return ;
+                if ( ! array->get_dimension() ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
+                        addCast = at->base;
+                }
 
                 Expression * begin, * end, * update, * cmp;
@@ -171 +176 @@
 
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -191 +196 @@
                 if ( isUnnamedBitfield( obj ) ) return;
 
-                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
+                Type * addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );

src/SymTab/Validate.cc

@@ -124 +124 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes final : public WithIndexer {
+        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
                 LinkReferenceToTypes( const Indexer *indexer );
                 void postvisit( TypeInstType *typeInst );
@@ -137 +137 @@
                 void postvisit( UnionDecl *unionDecl );
                 void postvisit( TraitDecl * traitDecl );
+
+                void previsit( StructDecl *structDecl );
+                void previsit( UnionDecl *unionDecl );
+
+                void renameGenericParams( std::list< TypeDecl * > & params );
 
           private:
@@ -147 +152 @@
                 ForwardStructsType forwardStructs;
                 ForwardUnionsType forwardUnions;
+                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
+                bool inGeneric = false;
         };
 
@@ -561 +568 @@
         }
 
+        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
+                // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
+                //   forall(otype T)
+                //   struct Box {
+                //     T x;
+                //   };
+                //   forall(otype T)
+                //   void f(Box(T) b) {
+                //     ...
+                //   }
+                // The T in Box and the T in f are different, so internally the naming must reflect that.
+                GuardValue( inGeneric );
+                inGeneric = ! params.empty();
+                for ( TypeDecl * td : params ) {
+                        td->name = "__" + td->name + "_generic_";
+                }
+        }
+
+        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
+                renameGenericParams( structDecl->parameters );
+        }
+
+        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
+                renameGenericParams( unionDecl->parameters );
+        }
+
         void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
@@ -588 +621 @@
 
         void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+                // ensure generic parameter instances are renamed like the base type
+                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
                 if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {