Changeset 2162c2c for src/Tuples

Timestamp:

Jan 11, 2017, 4:11:02 PM (9 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:

075734f

Parents:

bb82c03 (diff), d3a85240 (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

Location:

src/Tuples

Files:

• Explode.h (modified) (3 diffs)
• TupleAssignment.cc (modified) (6 diffs)
• TupleExpansion.cc (modified) (3 diffs)
• Tuples.h (modified) (1 diff)

src/Tuples/Explode.h

@@ -33 +33 @@
         /// helper function used by explode
         template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out ) {
+        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
+                if ( isTupleAssign ) {
+                        // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                                ResolvExpr::AltList alts;
+                                explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                for ( ResolvExpr::Alternative & alt : alts ) {
+                                        // distribute '&' over all components
+                                        alt.expr = distributeAddr( alt.expr );
+                                        *out++ = alt;
+                                }
+                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
+                                return;
+                        }
+                }
                 Type * res = expr->get_result();
-                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                        ResolvExpr::AltList alts;
-                        explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ) );
-                        for ( ResolvExpr::Alternative & alt : alts ) {
-                                // distribute '&' over all components
-                                alt.expr = distributeAddr( alt.expr );
-                                *out++ = alt;
-                        }
-                } else if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
                                 // can open tuple expr and dump its exploded components
                                 for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, out );
+                                        explodeUnique( expr, alt, indexer, out, isTupleAssign );
                                 }
                         } else {
@@ -58 +64 @@
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
                                         TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, out );
+                                        explodeUnique( idx, alt, indexer, out, isTupleAssign );
                                         delete idx;
                                 }
@@ -71 +77 @@
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
         template< typename OutputIterator >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explodeUnique( alt.expr, alt, indexer, out );
+        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+                explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
         }
 
         // explode list of alternatives
         template< typename AltIterator, typename OutputIterator >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out ) {
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out );
+                        explode( *altBegin, indexer, out, isTupleAssign );
                 }
         }
 
         template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explode( alts.begin(), alts.end(), indexer, out );
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+                explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
         }
 } // namespace Tuples

src/Tuples/TupleAssignment.cc

@@ -73 +73 @@
         };
 
-        /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
+        /// true if expr is an expression of tuple type
         bool isTuple( Expression *expr ) {
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
-                return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
+                return dynamic_cast< TupleType * >( expr->get_result() );
         }
 
@@ -142 +142 @@
                 matcher->match( new_assigns );
 
-                if ( new_assigns.empty() ) return;
+                if ( ! matcher->lhs.empty() || ! matcher->rhs.empty() ) {
+                        // if both lhs and rhs are empty then this is the empty tuple case, wherein it's okay for new_assigns to be empty.
+                        // if not the empty tuple case, return early so that no new alternatives are generated.
+                        if ( new_assigns.empty() ) return;
+                }
                 ResolvExpr::AltList current;
                 // now resolve new assignments
@@ -186 +190 @@
 
                 // explode the lhs so that each field of the tuple-valued-expr is assigned.
-                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs) );
+                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
 
                 // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
@@ -211 +215 @@
         TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
                 // explode the rhs so that each field of the tuple-valued-expr is assigned.
-                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs) );
+                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs), true );
         }
 
@@ -248 +252 @@
                 static UniqueName lhsNamer( "__massassign_L" );
                 static UniqueName rhsNamer( "__massassign_R" );
-                assert ( ! lhs.empty() && rhs.size() <= 1);
+                // empty tuple case falls into this matcher, hence the second part of the assert
+                assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
 
                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
                 for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
+                        // create a temporary object for each value in the lhs and create a call involving the rhs
                         ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
                         out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
@@ -263 +269 @@
                 static UniqueName rhsNamer( "__multassign_R" );
 
-                // xxx - need more complicated matching?
                 if ( lhs.size() == rhs.size() ) {
+                        // produce a new temporary object for each value in the lhs and rhs and pairwise create the calls
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;

src/Tuples/TupleExpansion.cc

@@ -144 +144 @@
 
         Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
-                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( memberExpr->get_member() ) ) {
+                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) {
                         Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
@@ -225 +225 @@
                                 decl->get_parameters().push_back( tyParam );
                         }
+                        if ( tupleType->size() == 0 ) {
+                                // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created.
+                                decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                        }
                         typeMap[mangleName] = decl;
                         addDeclaration( decl );
@@ -315 +319 @@
                         qualifiers &= type->get_qualifiers();
                 } // for
+                if ( exprs.empty() ) qualifiers = Type::Qualifiers();
                 return tupleType;
+        }
+
+        TypeInstType * isTtype( Type * type ) {
+                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( inst->get_baseType()->get_kind() == TypeDecl::Ttype ) {
+                                return inst;
+                        }
+                }
+                return nullptr;
         }
 

src/Tuples/Tuples.h

@@ -42 +42 @@
         Type * makeTupleType( const std::list< Expression * > & exprs );
 
+        /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
+        TypeInstType * isTtype( Type * type );
+
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );