Changeset d41280e for src/GenPoly/GenPoly.cc

Timestamp:

Feb 8, 2016, 10:07:42 AM (10 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

c44e622

Parents:

00ede9e (diff), bd85400 (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 'master' into gc_noraii

File:

• src/GenPoly/GenPoly.cc (modified) (4 diffs)

src/GenPoly/GenPoly.cc

@@ -36 +36 @@
         }
 
-        bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars ) {
-                bool doTransform = false;
+        ReferenceToType *isPolyRet( FunctionType *function ) {
                 if ( ! function->get_returnVals().empty() ) {
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( function->get_returnVals().front()->get_type() ) ) {
-        
-                                // figure out if the return type is specified by a type parameter
-                                for ( std::list< TypeDecl *>::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
-                                        if ( (*tyVar)->get_name() == typeInst->get_name() ) {
-                                                doTransform = true;
-                                                name = typeInst->get_name();
-                                                break;
-                                        } // if
-                                } // for
-                                if ( ! doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
-                                        doTransform = true;
-                                } // if
-                        } // if
-                } // if
-                return doTransform;
-        }
-
-        bool isPolyRet( FunctionType *function, std::string &name ) {
-                TyVarMap dummyTyVars;
-                return isPolyRet( function, name, dummyTyVars );
-        }
-
-        bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars ) {
-                std::string dummyString;
-                return isPolyRet( function, dummyString, otherTyVars );
+                        TyVarMap forallTypes;
+                        makeTyVarMap( function, forallTypes );
+                        return (ReferenceToType*)isPolyType( function->get_returnVals().front()->get_type(), forallTypes );
+                } // if
+                return 0;
         }
 
@@ -149 +127 @@
         }
 
+        Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
+                int dummy;
+                if ( ! levels ) { levels = &dummy; }
+                *levels = 0;
+
+                while ( true ) {
+                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+                                type = ptr->get_base();
+                                ++(*levels);
+                        } else if ( env ) {
+                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                                type = newType;
+                                        } else break;
+                                } else break;
+                        } else break;
+                }
+
+                return isPolyType( type, env );
+        }
+        
+        Type * hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels, const TypeSubstitution *env ) {
+                int dummy;
+                if ( ! levels ) { levels = &dummy; }
+                *levels = 0;
+
+                while ( true ) {
+                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+                                type = ptr->get_base();
+                                ++(*levels);
+                        } else if ( env ) {
+                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                                type = newType;
+                                        } else break;
+                                } else break;
+                        } else break;
+                }
+
+                return isPolyType( type, tyVars, env );
+        }
+
         FunctionType * getFunctionType( Type *ty ) {
                 PointerType *ptrType;
@@ -158 +178 @@
         }
 
+        VariableExpr * getBaseVar( Expression *expr, int *levels ) {
+                int dummy;
+                if ( ! levels ) { levels = &dummy; }
+                *levels = 0;
+
+                while ( true ) {
+                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( expr ) ) {
+                                return varExpr;
+                        } else if ( AddressExpr *addressExpr = dynamic_cast< AddressExpr* >( expr ) ) {
+                                expr = addressExpr->get_arg();
+                        } else if ( UntypedExpr *untypedExpr = dynamic_cast< UntypedExpr* >( expr ) ) {
+                                // look for compiler-inserted dereference operator
+                                NameExpr *fn = dynamic_cast< NameExpr* >( untypedExpr->get_function() );
+                                if ( ! fn || fn->get_name() != std::string("*?") ) return 0;
+                                expr = *untypedExpr->begin_args();
+                        } else break;
+
+                        ++(*levels);
+                }
+
+                return 0;
+        }
+
+        void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
+                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
+                        assert( *tyVar );
+                        tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();
+                }
+                if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
+                        makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+        
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
@@ -172 +225 @@
                 return std::string( "_alignof_" ) + SymTab::Mangler::mangleType( ty );
         }
+
+        std::string offsetofName( Type* ty ) {
+                return std::string( "_offsetof_" ) + SymTab::Mangler::mangleType( ty );
+        }
+
 } // namespace GenPoly