Changes in src/GenPoly/Box.cc [8dceeb7:4573e3c]

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();
@@ -180 +178 @@
                         /// 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
@@ -1418 +1414 @@
 
                 void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
-                        assert(false);
                         beginTypeScope( typedefDecl->get_base() );
                 }
@@ -1465 +1460 @@
                 }
 
-                /// 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() ) ) {
@@ -1509 +1465 @@
                                         // change initialization of a polymorphic value object to allocate via a VLA
                                         // (alloca was previously used, but can't be safely used in loops)
-                                        ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
+                                        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 );
                                         stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );