Changeset 837ce06

Timestamp:

Oct 19, 2017, 2:20:53 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

72f85de

Parents:

6840e7c

Message:

Fix cleanup function generation to always generate monomorphic functions

Location:

src

Files:

• InitTweak/FixInit.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (5 diffs)
• SymTab/Autogen.h (modified) (1 diff)

src/InitTweak/FixInit.cc

@@ -653 +653 @@
                         // wraps the more complicated code.
                         static UniqueName dtorNamer( "__cleanup_dtor" );
-                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type ), new CompoundStmt( noLabels ) );
+                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type, false ), new CompoundStmt( noLabels ) );
                         stmtsToAddBefore.push_back( new DeclStmt( noLabels, dtorFunc ) );
 
                         // the original code contains uses of objDecl - replace them with the newly generated 'this' parameter.
-                        ObjectDecl * thisParam = getThisParam( dtorFunc->type );
+                        ObjectDecl * thisParam = getParamThis( dtorFunc->type );
                         VarExprReplacer::replace( dtor, { std::make_pair( objDecl, thisParam ) } );
                         dtorFunc->statements->push_back( dtor );

src/SymTab/Autogen.cc

@@ -46 +46 @@
         /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
         struct FuncData {
-                typedef FunctionType * (*TypeGen)( Type * );
+                typedef FunctionType * (*TypeGen)( Type *, bool );
                 FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
                 std::string fname;
@@ -236 +236 @@
 
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
-        FunctionType * genDefaultType( Type * paramType ) {
-                const auto & typeParams = getGenericParams( paramType );
+        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-                cloneAll( typeParams, ftype->forall );
+                if ( maybePolymorphic ) {
+                        // only copy in
+                        const auto & typeParams = getGenericParams( paramType );
+                        cloneAll( typeParams, ftype->forall );
+                }
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->parameters.push_back( dstParam );
@@ -246 +249 @@
 
         /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
-        FunctionType * genCopyType( Type * paramType ) {
-                FunctionType *ftype = genDefaultType( paramType );
+        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic ) {
+                FunctionType *ftype = genDefaultType( paramType, maybePolymorphic );
                 ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->parameters.push_back( srcParam );
@@ -254 +257 @@
 
         /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
-        FunctionType * genAssignType( Type * paramType ) {
-                FunctionType *ftype = genCopyType( paramType );
+        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic ) {
+                FunctionType *ftype = genCopyType( paramType, maybePolymorphic );
                 ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->returnVals.push_back( returnVal );
@@ -313 +316 @@
                 for ( const FuncData & data : data ) {
                         // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
-                        FunctionType * ftype = data.genType( type );
+                        FunctionType * ftype = data.genType( type, true );
 
                         // destructor for concurrent type must be mutex

src/SymTab/Autogen.h

@@ -45 +45 @@
         extern FunctionDecl * dereferenceOperator;
 
-        // generate the type of an assignment function for paramType
-        FunctionType * genAssignType( Type * paramType );
-
-        // generate the type of a default constructor or destructor for paramType
-        FunctionType * genDefaultType( Type * paramType );
-
-        // generate the type of a copy constructor for paramType
-        FunctionType * genCopyType( Type * paramType );
+        /// generate the type of an assignment function for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a default constructor or destructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a copy constructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.