Reserve a state variable for the bailout function.

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 351 matching lines @@
 }
 
 /**
  * Contains the mapping between instructions and their names for code
  * generation, as well as the [CopyHandler] for each basic block.
  */
 class VariableNames {
   final Map<HInstruction, String> ownName;
   final Map<HBasicBlock, CopyHandler> copyHandlers;
   /**
-   * Name that is being used as a temporary to break cycles in
+   * Name that is used as a temporary to break cycles in
    * parallel copies. We make sure this name is not being used
    * anywhere by reserving it when we allocate names for instructions.
    */
   final String swapTemp;
+  /**
+   * Name that is used in bailout code. We make sure this name is not being used
+   * anywhere by reserving it when we allocate names for instructions.
+   */
+  final String stateName;
 
   VariableNames(Map<Element, String> parameterNames)
     : ownName = new Map<HInstruction, String>(),
       copyHandlers = new Map<HBasicBlock, CopyHandler>(),
-      swapTemp = computeSwapTemp(parameterNames);
+      swapTemp = computeFreshWithPrefix("t", parameterNames),
+      stateName = computeFreshWithPrefix("state", parameterNames);
 
-  static String computeSwapTemp(Map<Element, String> parameterNames) {
+  /** Returns a fresh variable with the given prefix. */
+  static String computeFreshWithPrefix(String prefix,
+                                       Map<Element, String> parameterNames) {
     Set<String> parameters = new Set<String>.from(parameterNames.getValues());
-    String name = 't0';
+    String name = '${prefix}0';
     int i = 1;
-    while (parameters.contains(name)) name = 't${i++}';
+    while (parameters.contains(name)) name = '$prefix${i++}';
     return name;
   }
 
   String getName(HInstruction instruction) {
     return ownName[instruction];
   }
 
   CopyHandler getCopyHandler(HBasicBlock block) {
     return copyHandlers[block];
   }
@@ skipping 19 matching lines @@
 class VariableNamer {
   final VariableNames names;
   final Set<String> usedNames;
   final Map<Element, String> parameterNames;
   final List<String> freeTemporaryNames;
   int temporaryIndex = 0;
 
   VariableNamer(LiveEnvironment environment, this.names, this.parameterNames)
     : usedNames = new Set<String>(),
       freeTemporaryNames = new List<String>() {
-    // [VariableNames.swapTemp] is being used when there is a cycle
-    // in a copy handler. Therefore we make sure no one will use it.
+    // [VariableNames.swapTemp] and [VariableNames.stateName] are being used
+    // throughout the function. Therefore we make sure no one uses it at any

[ngeoffray, 2012/10/15 14:12:29]

I'd prefer keeping the comment that was there before, and add an explicit
comment on why we need stateName too.

[floitsch, 2012/10/18 14:58:47]

https://codereview.chromium.org/11186048

+    // time.
     usedNames.add(names.swapTemp);
+    usedNames.add(names.stateName);
 
     // All liveIns instructions must have a name at this point, so we
     // add them to the list of used names.
     environment.liveInstructions.forEach((HInstruction instruction, int index) {
       String name = names.getName(instruction);
       if (name !== null) {
         usedNames.add(name);
       }
     });
   }
@@ skipping 200 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }