Changeset 8dceeb7

Timestamp:

Nov 23, 2017, 4:41:05 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:

178e4ec

Parents:

1ba5803

Message:

Monomorphize polymorphic aggregate (but not generic) members [fixes #61]

File:

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

src/GenPoly/Box.cc

@@ -167 +167 @@
                         Expression *postmutate( OffsetofExpr *offsetofExpr );
                         Expression *postmutate( OffsetPackExpr *offsetPackExpr );
+                        void premutate( StructDecl * );
+                        void premutate( UnionDecl * );
 
                         void beginScope();
@@ -178 +180 @@
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+                        /// change the type of generic aggregate members to char[]
+                        void mutateMembers( AggregateDecl * aggrDecl );
 
                         /// Enters a new scope for type-variables, adding the type variables from ty
@@ -1414 +1418 @@
 
                 void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
+                        assert(false);
                         beginTypeScope( typedefDecl->get_base() );
                 }
@@ -1460 +1465 @@
                 }
 
+                /// converts polymorphic type T into a suitable monomorphic representation, currently: __attribute__((aligned(8)) char[size_T]
+                Type * polyToMonoType( Type * declType ) {
+                        Type * charType = new BasicType( Type::Qualifiers(), BasicType::Kind::Char);
+                        Expression * size = new NameExpr( sizeofName( mangleType(declType) ) );
+                        Attribute * aligned = new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } );
+                        return new ArrayType( Type::Qualifiers(), charType, size,
+                                true, false, std::list<Attribute *>{ aligned } );
+                }
+
+                void PolyGenericCalculator::mutateMembers( AggregateDecl * aggrDecl ) {
+                        std::set< std::string > genericParams;
+                        for ( TypeDecl * td : aggrDecl->parameters ) {
+                                genericParams.insert( td->name );
+                        }
+                        for ( Declaration * decl : aggrDecl->members ) {
+                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( decl ) ) {
+                                        Type * ty = replaceTypeInst( field->type, env );
+                                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                                                // do not try to monomorphize generic parameters
+                                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
+                                                        // polymorphic aggregate members should be converted into monomorphic members.
+                                                        // Using char[size_T] here respects the expected sizing rules of an aggregate type.
+                                                        Type * newType = polyToMonoType( field->type );
+                                                        delete field->type;
+                                                        field->type = newType;
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                void PolyGenericCalculator::premutate( StructDecl * structDecl ) {
+                        mutateMembers( structDecl );
+                }
+
+                void PolyGenericCalculator::premutate( UnionDecl * unionDecl ) {
+                        mutateMembers( unionDecl );
+                }
+
                 void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
@@ -1465 +1509 @@
                                         // change initialization of a polymorphic value object to allocate via a VLA
                                         // (alloca was previously used, but can't be safely used in loops)
-                                        Type *declType = objectDecl->get_type();
-                                        ObjectDecl *newBuf = new ObjectDecl( bufNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0,
-                                                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 );
+                                        ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
                                         stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );