Rerun GVN if load elimination creates GVN candidates.

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.
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 41 matching lines @@
     void runPhase(OptimizationPhase phase) {
       measureSubtask(phase.name, () => phase.visitGraph(graph));
       backend.tracer.traceGraph(phase.name, graph);
       assert(graph.isValid());
     }
 
     bool trustPrimitives = compiler.options.trustPrimitives;
     CodegenRegistry registry = work.registry;
     Set<HInstruction> boundsChecked = new Set<HInstruction>();
     SsaCodeMotion codeMotion;
+    SsaLoadElimination loadElimination;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
         // Run trivial instruction simplification first to optimize
         // some patterns useful for type conversion.
         new SsaInstructionSimplifier(backend, closedWorld, this, registry),
         new SsaTypeConversionInserter(closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         new SsaTypePropagator(compiler, closedWorld),
         // After type propagation, more instructions can be
         // simplified.
         new SsaInstructionSimplifier(backend, closedWorld, this, registry),
         new SsaCheckInserter(
             trustPrimitives, backend, closedWorld, boundsChecked),
         new SsaInstructionSimplifier(backend, closedWorld, this, registry),
         new SsaCheckInserter(
             trustPrimitives, backend, closedWorld, boundsChecked),
         new SsaTypePropagator(compiler, closedWorld),
         // Run a dead code eliminator before LICM because dead
         // interceptors are often in the way of LICM'able instructions.
         new SsaDeadCodeEliminator(closedWorld, this),
         new SsaGlobalValueNumberer(),
         // After GVN, some instructions might need their type to be
         // updated because they now have different inputs.
         new SsaTypePropagator(compiler, closedWorld),
         codeMotion = new SsaCodeMotion(),
-        new SsaLoadElimination(backend, compiler, closedWorld),
+        loadElimination =
+            new SsaLoadElimination(backend, compiler, closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         // After GVN and load elimination the same value may be used in code
         // controlled by a test on the value, so redo 'conversion insertion' to
         // learn from the refined type.
         new SsaTypeConversionInserter(closedWorld),
         new SsaTypePropagator(compiler, closedWorld),
         new SsaValueRangeAnalyzer(backend.helpers, closedWorld, this),
         // Previous optimizations may have generated new
         // opportunities for instruction simplification.
         new SsaInstructionSimplifier(backend, closedWorld, this, registry),
         new SsaCheckInserter(
             trustPrimitives, backend, closedWorld, boundsChecked),
       ];
       phases.forEach(runPhase);
 
       // Simplifying interceptors is not strictly just an optimization, it is
       // required for implementation correctness because the code generator
       // assumes it is always performed.
       runPhase(new SsaSimplifyInterceptors(
           compiler, closedWorld, work.element.enclosingClass));
 
       SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(closedWorld, this);
       runPhase(dce);
-      if (codeMotion.movedCode || dce.eliminatedSideEffects) {
+      if (codeMotion.movedCode ||
+          dce.eliminatedSideEffects ||
+          loadElimination.newGvnCandidates) {
         phases = <OptimizationPhase>[
           new SsaTypePropagator(compiler, closedWorld),
           new SsaGlobalValueNumberer(),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(backend.helpers, closedWorld, this),
           new SsaInstructionSimplifier(backend, closedWorld, this, registry),
           new SsaCheckInserter(
               trustPrimitives, backend, closedWorld, boundsChecked),
           new SsaSimplifyInterceptors(
               compiler, closedWorld, work.element.enclosingClass),
@@ skipping 2129 matching lines @@
  * example [HFieldGet]), when it knows the value stored in that memory
  * location.
  */
 class SsaLoadElimination extends HBaseVisitor implements OptimizationPhase {
   final JavaScriptBackend backend;
   final Compiler compiler;
   final ClosedWorld closedWorld;
   final String name = "SsaLoadElimination";
   MemorySet memorySet;
   List<MemorySet> memories;
+  bool newGvnCandidates = false;
 
   SsaLoadElimination(this.backend, this.compiler, this.closedWorld);
 
   void visitGraph(HGraph graph) {
     memories = new List<MemorySet>(graph.blocks.length);
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = 0; i < blocks.length; i++) {
       HBasicBlock block = blocks[i];
       visitBasicBlock(block);
       if (block.successors.isNotEmpty && block.successors[0].isLoopHeader()) {
@@ skipping 34 matching lines @@
 
     memories[block.id] = memorySet;
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction.accept(this);
       instruction = next;
     }
   }
 
+  void checkNewGvnCandidates(HInstruction instruction, HInstruction existing) {
+    if (newGvnCandidates) return;
+    bool hasUseGvn(HInstruction insn) => insn.nonCheck().useGvn();
+    if (instruction.usedBy.any(hasUseGvn) && existing.usedBy.any(hasUseGvn)) {
+      newGvnCandidates = true;
+    }
+  }
+
   void visitFieldGet(HFieldGet instruction) {
     if (instruction.isNullCheck) return;
     FieldEntity element = instruction.element;
     HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     _visitFieldGet(element, receiver, instruction);
   }
 
   void visitGetLength(HGetLength instruction) {
     _visitFieldGet(backend.helpers.jsIndexableLength,
         instruction.receiver.nonCheck(), instruction);
   }
 
   void _visitFieldGet(
       MemberEntity element, HInstruction receiver, HInstruction instruction) {
     HInstruction existing = memorySet.lookupFieldValue(element, receiver);
     if (existing != null) {
+      checkNewGvnCandidates(instruction, existing);
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
       memorySet.registerFieldValue(element, receiver, instruction);
     }
   }
 
   void visitFieldSet(HFieldSet instruction) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     memorySet.registerFieldValueUpdate(
@@ skipping 62 matching lines @@
   }
 
   void visitLazyStatic(HLazyStatic instruction) {
     FieldEntity field = instruction.element;
     handleStaticLoad(field, instruction);
   }
 
   void handleStaticLoad(MemberEntity element, HInstruction instruction) {
     HInstruction existing = memorySet.lookupFieldValue(element, null);
     if (existing != null) {
+      checkNewGvnCandidates(instruction, existing);
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
       memorySet.registerFieldValue(element, null, instruction);
     }
   }
 
   void visitStatic(HStatic instruction) {
     handleStaticLoad(instruction.element, instruction);
   }
 
   void visitStaticStore(HStaticStore instruction) {
     memorySet.registerFieldValueUpdate(
         instruction.element, null, instruction.inputs.last);
   }
 
   void visitLiteralList(HLiteralList instruction) {
     memorySet.registerAllocation(instruction);
     memorySet.killAffectedBy(instruction);
     // TODO(sra): Set initial keyed values.
     // TODO(sra): Set initial length.
   }
 
   void visitIndex(HIndex instruction) {
     HInstruction receiver = instruction.receiver.nonCheck();
     HInstruction existing =
         memorySet.lookupKeyedValue(receiver, instruction.index);
     if (existing != null) {
+      checkNewGvnCandidates(instruction, existing);
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
       memorySet.registerKeyedValue(receiver, instruction.index, instruction);
     }
   }
 
   void visitIndexAssign(HIndexAssign instruction) {
     HInstruction receiver = instruction.receiver.nonCheck();
     memorySet.registerKeyedValueUpdate(
@@ skipping 335 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }