Changeset 7754cde

Timestamp:

Dec 16, 2015, 4:59:58 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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, string, with_gc

Children:

69911c11

Parents:

0f889a77

Message:

First draft of passing generic size/align

Location:

src/GenPoly

Files:

• Box.cc (modified) (5 diffs)
• GenPoly.cc (modified) (1 diff)
• GenPoly.h (modified) (1 diff)
• ScrubTyVars.cc (modified) (2 diffs)
• Specialize.cc (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -306 +306 @@
 
                 void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                        // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
                                 ResolvExpr::EqvClass eqvClass;
@@ -321 +322 @@
                                 } // if
                         } // for
+
+                        // add size/align for generic types to parameter list
+                        //assert( ! appExpr->get_function()->get_results().empty() );
+                        if ( appExpr->get_function()->get_results().empty() ) return;
+                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
+                        assert( funcType );
+                        
+                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
+                        std::list< Expression* >::const_iterator fnArg = arg;
+                        std::set< std::string > seenTypes; //< sizeofName for generic types we've seen
+                        for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
+                                Type *parmType = (*fnParm)->get_type();
+                                if ( ! dynamic_cast< TypeInstType* >( parmType ) && isPolyType( parmType, exprTyVars ) ) {
+                                        std::string sizeName = sizeofName( parmType );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+
+                                        assert( ! (*fnArg)->get_results().empty() );
+                                        Type *argType = (*fnArg)->get_results().front();
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( argType->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( argType->clone() ) );
+                                        arg++;
+
+                                        seenTypes.insert( sizeName );
+                                }
+                        }
                 }
 
@@ -971 +998 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( funcType, scopeTyVars );
-  
+
+                        // move polymorphic return type to parameter list
                         std::string typeName;
                         if ( isPolyRet( funcType, typeName ) ) {
@@ -979 +1007 @@
                                 funcType->get_returnVals().pop_front();
                         }
-  
+
+                        // add size/align and assertions for type parameters to parameter list
                         std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
                         std::list< DeclarationWithType *> inferredParams;
@@ -1007 +1036 @@
                                 (*tyParm)->get_assertions().clear();
                         }
+
+                        // add size/align for generic types to parameter list
+                        std::set< std::string > seenTypes; //< sizeofName for generic types we've seen
+                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                                Type *parmType = (*fnParm)->get_type();
+                                if ( ! dynamic_cast< TypeInstType* >( parmType ) && isPolyType( parmType, scopeTyVars ) ) {
+                                        std::string sizeName = sizeofName( parmType );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+                                        
+                                        ObjectDecl *sizeParm, *alignParm;
+                                        sizeParm = newObj.clone();
+                                        sizeParm->set_name( sizeName );
+                                        last = funcType->get_parameters().insert( last, sizeParm );
+                                        ++last;
+
+                                        alignParm = newObj.clone();
+                                        alignParm->set_name( alignofName( parmType ) );
+                                        last = funcType->get_parameters().insert( last, alignParm );
+                                        ++last;
+
+                                        seenTypes.insert( sizeName );
+                                }
+                        }
+
+                        // splice assertion parameters into parameter list
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );

src/GenPoly/GenPoly.cc

@@ -149 +149 @@
         }
 
+        FunctionType * getFunctionType( Type *ty ) {
+                PointerType *ptrType;
+                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
+                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
+                } else {
+                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
+                }
+        }
+
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

@@ -48 +48 @@
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
 
+        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
+        FunctionType * getFunctionType( Type *ty );
+
         /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );

src/GenPoly/ScrubTyVars.cc

@@ -46 +46 @@
         Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
                 // sizeof( T ) => _sizeof_T parameter, which is the size of T
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) {
-                        Expression *expr = new NameExpr( sizeofName( typeInst ) );
+                if ( Type *polyType = isPolyType( szeof->get_type() ) ) {
+                        Expression *expr = new NameExpr( sizeofName( polyType ) );
                         return expr;
                 } else {
@@ -56 +56 @@
         Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) {
                 // alignof( T ) => _alignof_T parameter, which is the alignment of T
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( algnof->get_type() ) ) {
-                        Expression *expr = new NameExpr( alignofName( typeInst ) );
+                if ( Type *polyType = isPolyType( algnof->get_type() ) ) {
+                        Expression *expr = new NameExpr( alignofName( polyType ) );
                         return expr;
                 } else {

src/GenPoly/Specialize.cc

@@ -17 +17 @@
 
 #include "Specialize.h"
+#include "GenPoly.h"
 #include "PolyMutator.h"
 
@@ -87 +88 @@
         }
 
-        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
-        FunctionType * getFunctionType( Type *ty ) {
-                PointerType *ptrType;
-                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
-                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
-                } else {
-                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
-                }
-        }
-
         /// Generates a thunk that calls `actual` with type `funType` and returns its address
         Expression * Specialize::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {