Changeset 63db3d76 for src/GenPoly

Timestamp:

Dec 4, 2015, 3:13:40 PM (9 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:

cdec5af

Parents:

47534159

Message:

Temporarily roll back dtype-to-void optimization until it works properly

File:

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

src/GenPoly/InstantiateGeneric.cc

@@ -77 +77 @@
                 std::list< Type* > params;  ///< Instantiation parameters
         };
-
+        
         /// Maps a concrete type to the instantiated struct type, accounting for scope
         class InstantiationMap {
@@ -143 +143 @@
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
         class Instantiate : public DeclMutator {
+                /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap instantiations;
+                /// Namer for concrete types
                 UniqueName typeNamer;
 
@@ -149 +151 @@
                 Instantiate() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
 
-//              virtual Declaration* mutate( StructDecl *aggregateDecl );
-//              virtual Declaration* mutate( UnionDecl *aggregateDecl );
-
                 virtual Type* mutate( StructInstType *inst );
                 virtual Type* mutate( UnionInstType *inst );
+
+//              virtual Expression* mutate( MemberExpr *memberExpr );
                 
                 virtual void doBeginScope();
@@ -166 +167 @@
         /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type
         bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {
-                bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
+                bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
 
                 // substitute concrete types for given parameters, and incomplete types for placeholders
@@ -172 +173 @@
                 std::list< Expression* >::const_iterator param = params.begin();
                 for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {
-                        switch ( (*baseParam)->get_kind() ) {
-                        case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
+//                      switch ( (*baseParam)->get_kind() ) {
+//                      case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
                                 assert(paramType && "Aggregate parameters should be type expressions");
@@ -179 +180 @@
                                 // check that the substituted type isn't a type variable itself
                                 if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
-                                        allConcrete = false;
+                                        allConcrete = false;
                                 }
-                                break;
-                        }
-                        case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-                                out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-                                break;
-                        case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-                                out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-                                break;
-                        }
-                }
-
-                // if not enough parameters given, substitute remaining incomplete types for placeholders
-                for ( ; baseParam != baseParams.end(); ++baseParam ) {
-                        switch ( (*baseParam)->get_kind() ) {
-                        case TypeDecl::Any:    // no more substitutions here, fail early
-                                return false;
-                        case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-                                out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-                                break;
-                        case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-                                out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-                                break;
-                        }
-                }
-
-                return allConcrete;
-        }
-        
+//                              break;
+//                      }
+//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+//                              break;
+//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+//                              break;
+//                      }
+                }
+
+                // if any parameters left over, not done
+                if ( baseParam != baseParams.end() ) return false;
+//              // if not enough parameters given, substitute remaining incomplete types for placeholders
+//              for ( ; baseParam != baseParams.end(); ++baseParam ) {
+//                      switch ( (*baseParam)->get_kind() ) {
+//                      case TypeDecl::Any:    // no more substitutions here, fail early
+//                              return false;
+//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+//                              break;
+//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+//                              break;
+//                      }
+//              }
+
+                return allConcrete;
+        }
+
         /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out
         void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs, 
@@ -288 +291 @@
                 return newInst;
         }
+
+//      /// Gets the base struct or union declaration for a member expression; NULL if not applicable
+//      AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {
+//              // get variable for member aggregate
+//              VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );
+//              if ( ! varExpr ) return NULL;
+// 
+//              // get object for variable
+//              ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
+//              if ( ! objectDecl ) return NULL;
+// 
+//              // get base declaration from object type
+//              Type *objectType = objectDecl->get_type();
+//              StructInstType *structType = dynamic_cast< StructInstType* >( objectType );
+//              if ( structType ) return structType->get_baseStruct();
+//              UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );
+//              if ( unionType ) return unionType->get_baseUnion();
+// 
+//              return NULL;
+//      }
+// 
+//      /// Finds the declaration with the given name, returning decls.end() if none such
+//      std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {
+//              for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
+//                      if ( (*decl)->get_name() == name ) return decl;
+//              }
+//              return decls.end();
+//      }
+//      
+//      Expression* Instantiate::mutate( MemberExpr *memberExpr ) {
+//              // mutate, exiting early if no longer MemberExpr
+//              Expression *expr = Mutator::mutate( memberExpr );
+//              memberExpr = dynamic_cast< MemberExpr* >( expr );
+//              if ( ! memberExpr ) return expr;
+// 
+//              // get declaration of member and base declaration of member, exiting early if not found
+//              AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );
+//              if ( ! memberBase ) return memberExpr;
+//              DeclarationWithType *memberDecl = memberExpr->get_member();
+//              std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );
+//              if ( baseIt == memberBase->get_members().end() ) return memberExpr;
+//              DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );
+//              if ( ! baseDecl ) return memberExpr;
+// 
+//              // check if stated type of the member is not the type of the member's declaration; if so, need a cast
+//              // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker
+//              SymTab::Indexer dummy;
+//              if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;
+//              else return new CastExpr( memberExpr, memberDecl->get_type() );
+//      }
         
         void Instantiate::doBeginScope() {
                 DeclMutator::doBeginScope();
-                // push a new concrete type scope
                 instantiations.beginScope();
         }
@@ -297 +349 @@
         void Instantiate::doEndScope() {
                 DeclMutator::doEndScope();
-                // pop the last concrete type scope
                 instantiations.endScope();
         }