Use GVN for length loads from arrays and strings.

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.
   int end;
   LiveRange(this.start, this.end) {
     assert(start <= end);
   }
 
   String toString() => '[$start $end[';
 }
 
 /**
  * The [LiveInterval] class contains the list of ranges where an
  * instruction is live.
  */
 class LiveInterval {
   /**
-   * The id where there instruction is defined.
+   * The id where the instruction is defined.
    */
   int start;
   final List<LiveRange> ranges;
   LiveInterval() : ranges = <LiveRange>[];
 
   /**
    * Update all ranges that are contained in [from, to[ to
    * die at [to].
    */
   void loopUpdate(int from, int to) {
@@ skipping 95 matching lines @@
       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
+    // Note that we are visiting the graph 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.
       var input = instruction.checkedInput;
       while (input is HCheck) input = input.checkedInput;
       liveInstructions.putIfAbsent(input, () => userId);
     }
   }
@@ skipping 430 matching lines @@
    * 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);
   }
 
   void handleInstruction(HInstruction instruction, VariableNamer namer) {
-    for (int i = 0, len = instruction.inputs.length; i < len; i++) {
-      HInstruction input = instruction.inputs[i];
-      // If [input] has a name, and its use here is the last use, free
-      // its name.
-      if (needsName(input) && diesAt(input, instruction)) {
-        namer.freeName(input);
+    // TODO(ager): We cannot perform this check to free names for
+    // HCheck instructions because they are special cased to have the
+    // same live intervals as the instruction they are checking. This
+    // includes sharing the start id with the checked
+    // input. Therefore, for HCheck(checkedInput, otherInput) we would
+    // end up checking that otherInput dies not here, but at the
+    // location of checkedInput. We should preserve the start id for
+    // the check instruction.
+    if (instruction is! HCheck) {
+      for (int i = 0, len = instruction.inputs.length; i < len; i++) {
+        HInstruction input = instruction.inputs[i];
+        // If [input] has a name, and its use here is the last use, free
+        // its name.
+        if (needsName(input) && diesAt(input, instruction)) {
+          namer.freeName(input);
+        }
       }
     }
 
     if (needsName(instruction)) {
       namer.allocateName(instruction);
     }
   }
 
   void handlePhi(HPhi phi, VariableNamer namer) {
     if (!needsName(phi)) return;
 
     for (int i = 0; i < phi.inputs.length; i++) {
       HInstruction input = phi.inputs[i];
       HBasicBlock predecessor = phi.block.predecessors[i];
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }