Changeset aee472e

Timestamp:

May 17, 2018, 4:37:31 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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

Children:

bfd0a1a

Parents:

d20a343

git-author:

Rob Schluntz <rschlunt@…> (05/17/18 16:37:16)

git-committer:

Rob Schluntz <rschlunt@…> (05/17/18 16:37:31)

Message:

Reduce the number of unnecessary temporaries generated for member tuple expressions, reduce pure (no side-effect) tuple index expressions to the relevant component expression

File:

• src/Tuples/TupleExpansion.cc (modified) (3 diffs)

src/Tuples/TupleExpansion.cc

@@ -30 +30 @@
 #include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
 #include "SynTree/Visitor.h"      // for Visitor
+#include "Tuples.h"
 
 class CompoundStmt;
@@ -128 +129 @@
                         Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
-                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
-                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
-                        aggr = new UniqueExpr( aggr );
+                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
@@ -235 +234 @@
                 delete tupleExpr;
 
+                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
+                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
+                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
+                                assert( tupleExpr->exprs.size() > idx );
+                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
+                                Expression * ret = expr;
+                                ret->env = env;
+                                expr = nullptr; // remove from list so it can safely be deleted
+                                delete tupleExpr;
+                                return ret;
+                        }
+                }
+
                 StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
                 StructDecl * structDecl = type->baseStruct;