Changeset 353d168 for src/GenPoly/Box.cc

Timestamp:

Aug 19, 2015, 3:59:45 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

830c21a

Parents:

18997b9 (diff), 4aa0858 (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 'override-autogen' into ctor

Conflicts:

src/Parser/ParseNode.h

File:

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

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jun 24 16:19:07 2015
-// Update Count     : 10
+// Last Modified On : Tue Aug 11 16:22:35 2015
+// Update Count     : 89
 //
 
@@ -77 +77 @@
                         Expression *handleIntrinsics( ApplicationExpr *appExpr );
                         ObjectDecl *makeTemporary( Type *type );
-  
+
+                        typedef std::map< std::string, FunctionDecl *> AdapterMap;
                         std::map< std::string, DeclarationWithType *> assignOps;
-                        typedef std::map< std::string, FunctionDecl *> AdapterMap;
                         std::stack< AdapterMap > adapters;
                         DeclarationWithType *retval;
@@ -168 +168 @@
                         TyVarMap dummyTyVars;
                         return isPolyRet( function, name, dummyTyVars );
+                }
+
+                bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars ) {
+                        std::string dummyString;
+                        return isPolyRet( function, dummyString, otherTyVars );
                 }
 
@@ -526 +531 @@
                 }
 
-                void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
+                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
+                        // collect a list of function types passed as parameters or implicit parameters (assertions)
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                         std::list< FunctionType *> functions;
@@ -537 +543 @@
                                 findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
                         } // for
+
+                        // parameter function types for which an appropriate adapter has been generated.
+                        // we cannot use the types after applying substitutions, since two different 
+                        // parameter types may be unified to the same type
                         std::set< std::string > adaptersDone;
+
                         for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
+                                FunctionType *originalFunction = (*funType)->clone();
                                 FunctionType *realFunction = (*funType)->clone();
-                                assert( env );
-                                env->apply( realFunction );
-
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
+
+                                // only attempt to create an adapter or pass one as a parameter if we haven't 
+                                // already done so for this pre-substitution parameter function type.
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-                                        AdapterMap & adapters = Pass1::adapters.top();
-                                        AdapterMap::iterator adapter = adapters.find( mangleName );
+                                        std::string mangleName = SymTab::Mangler::mangle( realFunction );
+                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
+                                        
+                                        // apply substitution to type variables to figure out what the 
+                                        // adapter's type should look like
+                                        assert( env );
+                                        env->apply( realFunction );
+                                        mangleName = SymTab::Mangler::mangle( realFunction );
 
                                         if ( needsAdapter( realFunction, exprTyVars, true ) ) {
@@ -553 +571 @@
                                                 // create a new adapter.
                                                 appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
-                                                continue;
-                                        } else if ( adapter == adapters.end() ) {
-                                                FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
-                                                adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
-                                                stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                        } else {
+                                                if ( isPolyRet( originalFunction, exprTyVars ) ) {
+                                                        // if the return type involved polymorphic types, then
+                                                        // the adapter will need to take those polymorphic types
+                                                        // as pointers. Therefore, there can be two different
+                                                        // functions with the same mangled name, so we need two adapter map
+                                                        // stacks and also we need the mangled names to be different.
+                                                        mangleName += "polyret_";
+                                                }
+
+                                                AdapterMap & adapters = Pass1::adapters.top();
+                                                AdapterMap::iterator adapter = adapters.find( mangleName );
+                                                if ( adapter == adapters.end() ) {
+                                                        // adapter has not been created yet in the current scope, so define it
+                                                        FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
+                                                        adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
+                                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                                } // if
+                                                assert( adapter != adapters.end() );
+
+                                                // add the appropriate adapter as a parameter
+                                                appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
                                         } // if
-                                        assert( adapter != adapters.end() );
-                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
-                                        // appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
-                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 } // if
                         } // for
@@ -880 +911 @@
 
                 void Pass1::doBeginScope() {
+                        // actually, maybe this could (should?) push
+                        // a copy of the current map
                         adapters.push(AdapterMap());
                 }
@@ -1051 +1084 @@
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
+                                        // change initialization of a polymorphic value object
+                                        // to allocate storage with alloca
                                         TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
                                         assert( typeInst );
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
                                         alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
-                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                                        assign->get_args().push_back( new VariableExpr( objectDecl ) );
-                                        assign->get_args().push_back( alloc );
-                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
+
+                                        delete objectDecl->get_init();
+
+                                        std::list<Expression*> designators;
+                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
                                 }
                         }