Changeset f710aca for src/GenPoly/Specialize.cc

Timestamp:

Aug 15, 2017, 1:21:03 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

97e3296

Parents:

303406a (diff), ae4038d (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/GenPoly/Specialize.cc (modified) (2 diffs)

src/GenPoly/Specialize.cc

@@ -93 +93 @@
         }
 
+        // walk into tuple type and find the number of components
+        size_t singleParameterSize( Type * type ) {
+                if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) {
+                        size_t sz = 0;
+                        for ( Type * t : *tt ) {
+                                sz += singleParameterSize( t );
+                        }
+                        return sz;
+                } else {
+                        return 1;
+                }
+        }
+
+        // find the total number of components in a parameter list
+        size_t functionParameterSize( FunctionType * ftype ) {
+                size_t sz = 0;
+                for ( DeclarationWithType * p : ftype->get_parameters() ) {
+                        sz += singleParameterSize( p->get_type() );
+                }
+                return sz;
+        }
+
         bool needsTupleSpecialization( Type *formalType, Type *actualType ) {
                 // Needs tuple specialization if the structure of the formal type and actual type do not match.
@@ -103 +125 @@
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
+                        // Can't tuple specialize if parameter sizes deeply-differ.
+                        if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
+                        // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize
                         if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
+                        // total parameter size can be the same, while individual parameters can have different structure
                         for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {
                                 DeclarationWithType * formal = std::get<0>(params);