Fix performance regression after adding inlining support for operators, [], and []=.

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
@@ skipping 204 matching lines @@
     }
   }
 
   void markInputsAsLiveInEnvironment(HInstruction instruction,
                                      LiveEnvironment environment) {
     for (int i = 0, len = instruction.inputs.length; i < len; i++) {
       markAsLiveInEnvironment(instruction.inputs[i], environment);
     }
   }
 
-  HInstruction unwrap(instruction) {
-    do {
-      instruction = instruction.checkedInput;
-    } while (instruction is HCheck);
-    return instruction;
-  }
-
   void markAsLiveInEnvironment(HInstruction instruction,
                                LiveEnvironment environment) {
     if (generateAtUseSite.contains(instruction)) {
       markInputsAsLiveInEnvironment(instruction, environment);
     } else {
       environment.add(instruction, instructionId);
       // Special case the HCheck instruction to mark the actual
       // checked instruction live. The checked instruction and the
       // [HCheck] will share the same live ranges.
       if (instruction is HCheck) {
-        HInstruction checked = unwrap(instruction);
+        HCheck check = instruction;
+        HInstruction checked = check.unwrap();
         if (!generateAtUseSite.contains(checked)) {
           environment.add(checked, instructionId);
         }
       }
     }
   }
 
   void removeFromEnvironment(HInstruction instruction,
                              LiveEnvironment environment) {
     environment.remove(instruction, instructionId);
     // Special case the HCheck instruction to have the same live
     // interval as the instruction it is checking.
     if (instruction is HCheck) {
-      HInstruction checked = unwrap(instruction);
+      HCheck check = instruction;
+      HInstruction checked = check.unwrap();
       if (!generateAtUseSite.contains(checked)) {
         liveIntervals.putIfAbsent(checked, () => new LiveInterval());
         // Unconditionally force the live ranges of the HCheck to
         // be the live ranges of the instruction it is checking.
         liveIntervals[instruction] =
             new LiveInterval.forCheck(instructionId, liveIntervals[checked]);
       }
     }
   }
 
@@ skipping 351 matching lines @@
 
     block.forEachInstruction((HInstruction instruction) {
       handleInstruction(instruction, namer);
     });
   }
 
   /**
    * Returns whether [instruction] needs a name. Instructions that
    * have no users or that are generated at use site do not need a name.
    */
-  bool needsName(HInstruction instruction) {
+  bool needsName(instruction) {
     if (instruction is HThis) return false;
     if (instruction is HParameterValue) return true;
     if (instruction.usedBy.isEmpty) return false;
     if (generateAtUseSite.contains(instruction)) return false;
-    // A [HCheck] instruction that has control flow needs a name only if its
-    // checked input needs a name (for example, a checked [HConstant] does not
-    // need a name).
-    if (instruction is HCheck && instruction.isControlFlow()) {
-      HCheck check = instruction;
-      return needsName(instruction.checkedInput);
+    // A [HCheck] instruction needs a name only if its
+    // checked input does not have a fixed name or value.
+    if (instruction is HCheck) {
+      return !instruction.unwrap().isCodeMotionInvariant();
     }
     return true;
   }
 
   /**
    * Returns whether [instruction] dies at the instruction [at].
    */
   bool diesAt(HInstruction instruction, HInstruction at) {
     LiveInterval atInterval = liveIntervals[at];
     LiveInterval instructionInterval = liveIntervals[instruction];
@@ skipping 43 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }