Remove trivial dead stores during dead code elimination

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 964 matching lines @@
         node, node.receiver, graph.addConstantInt(0, backend.compiler));
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final String name = "SsaDeadCodeEliminator";
 
   final Compiler compiler;
   final SsaOptimizerTask optimizer;
   SsaLiveBlockAnalyzer analyzer;
+  Map<HInstruction, bool> trivialDeadStoreReceivers = <HInstruction, bool>{};

[floitsch, 2014/12/10 20:33:04]

Do you think a Map is warranted?
maybe just a maplet?

[sra1, 2014/12/10 23:08:47]

Done.

   bool eliminatedSideEffects = false;
   SsaDeadCodeEliminator(this.compiler, this.optimizer);
 
   HInstruction zapInstructionCache;
   HInstruction get zapInstruction {
     if (zapInstructionCache == null) {
       // A constant with no type does not pollute types at phi nodes.
       ConstantValue constant =
           new DummyConstantValue(const TypeMask.nonNullEmpty());
       zapInstructionCache = analyzer.graph.addConstant(constant, compiler);
@@ skipping 20 matching lines @@
         // just jumps to a single predecessor, visit this predecessor.
         assert(current.block.successors.length == 1);
         current = current.block.successors[0].first;
       } else {
         current = current.next;
       }
     } while (current != null);
     return false;
   }
 
+  bool isTrivialDeadStoreReceiver(HInstruction instruction) {
+    // For an allocation, if all the loads are dead (awaiting removal after
+    // SsaLoadElimination) and the only other uses are stores, then the
+    // allocation does not escape which makes all the stores dead too.
+    bool isDeadUse(HInstruction use) {
+      if (use is HFieldSet) {
+        // The use must be the receiver.  If the use is also the argument, i.e.

[floitsch, 2014/12/10 20:33:04]

Even if the use...

[sra1, 2014/12/10 23:08:47]

Done.

+        // a.x = a, the store is still dead if all other uses are dead.
+        if (use.getDartReceiver(compiler) == instruction) return true;
+      } else if (use is HFieldGet) {
+        assert(use.getDartReceiver(compiler) == instruction);
+        if (isDeadCode(use)) return true;
+      }
+      return false;
+    }
+    return instruction is HForeignNew
+        && trivialDeadStoreReceivers.putIfAbsent(instruction,
+            () => instruction.usedBy.every(isDeadUse));
+  }
+
+  bool isTrivialDeadStore(HInstruction instruction) {
+    return instruction is HFieldSet
+        && isTrivialDeadStoreReceiver(instruction.getDartReceiver(compiler));
+  }
+
   bool isDeadCode(HInstruction instruction) {
     if (!instruction.usedBy.isEmpty) return false;
+    if (isTrivialDeadStore(instruction)) return true;
     if (instruction.sideEffects.hasSideEffects()) return false;
     if (instruction.canThrow()
         && instruction.onlyThrowsNSM()
         && hasFollowingThrowingNSM(instruction)) {
       return true;
     }
     return !instruction.canThrow()
            && instruction is !HParameterValue
            && instruction is !HLocalSet;
   }
@@ skipping 1123 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }