Reapply change to GVN all HFieldGet instructions.

lib/compiler/implementation/ssa/variable_allocator.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.
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
   final int start;
   // [end] is not final because it can be updated due to loops.
@@ skipping 100 matching lines @@
    * updates the live interval of [instruction] to contain the new
    * range: [id, / id contained in [liveInstructions] /].
    */
   void remove(HInstruction instruction, int id) {
     // Special case the HCheck instruction to have the same live
     // interval as the instruction it is checking.
     if (instruction is HCheck) {
       var input = instruction.checkedInput;
       while (input is HCheck) input = input.checkedInput;
       liveIntervals.putIfAbsent(input, () => new LiveInterval());
-      liveIntervals.putIfAbsent(instruction, () => liveIntervals[input]);
+      // Unconditionally force the live interval of the HCheck to
+      // be the live interval of the instruction it is checking.
+      liveIntervals[instruction] = liveIntervals[input];

[ngeoffray, 2012/06/15 19:45:33]

Nice catch! Hope that was easy to spot :) I should have done it unconditionnaly
(see comment lines 115 and 116), but left a few bugs there :) (eg the
duplication lines 141 and 145 of original code). Thanks for fixing it!

     } else {
       LiveInterval range = liveIntervals.putIfAbsent(
           instruction, () => new LiveInterval());
       int lastId = liveInstructions[instruction];
       // If [lastId] is null, then this instruction is not being used.
       range.add(new LiveRange(id, lastId == null ? id : lastId));
       // The instruction is defined at [id].
       range.start = id;
     }
     liveInstructions.remove(instruction);
   }
 
   /**
    * Add [instruction] to the liveIn set. If the instruction is not
    * already in the set, we save the id where it dies.
    */
   void add(HInstruction instruction, int userId) {
     // Note that we are visiting the grap in post-dominator order, so
     // the first time we see a variable is when it dies.
     liveInstructions.putIfAbsent(instruction, () => userId);
     if (instruction is HCheck) {
       // Special case the HCheck instruction to mark the actual
       // checked instruction live.
-      liveInstructions.putIfAbsent(instruction, () => userId);
       var input = instruction.checkedInput;
       while (input is HCheck) input = input.checkedInput;
       liveInstructions.putIfAbsent(input, () => userId);
     }
   }
 
   /**
    * Merge this environment with [other]. Update the end id of
    * instructions in case they are different between this and [other].
    */
@@ skipping 413 matching lines @@
     if (generateAtUseSite.contains(instruction)) return false;
     // A [HCheck] instruction that has control flow needs a name only if its
     // checked input needs a name (e.g. a check [HConstant] does not
     // need a name).
     if (instruction is HCheck && instruction.isControlFlow()) {
       HCheck check = instruction;
       return needsName(instruction.checkedInput);
     }
     return true;
   }
- 
+
   /**
    * Returns whether [instruction] dies at the instruction [at].
    */
   bool diesAt(HInstruction instruction, HInstruction at) {
     LiveInterval atInterval = liveIntervals[at];
     LiveInterval instructionInterval = liveIntervals[instruction];
     int start = atInterval.start;
     return instructionInterval.diesAt(start);
   }
 
@@ skipping 21 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }