dartfmt pkg/compiler

pkg/compiler/lib/src/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.
 
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../js_backend/js_backend.dart';
 
 import 'nodes.dart';
 
@@ skipping 97 matching lines @@
    * instruction.
    */
   final Map<HInstruction, int> liveInstructions;
 
   /**
    * Map containing the live intervals of instructions.
    */
   final Map<HInstruction, LiveInterval> liveIntervals;
 
   LiveEnvironment(this.liveIntervals, this.endId)
-    : liveInstructions = new Map<HInstruction, int>(),
-      loopMarkers = new Map<HBasicBlock, int>();
+      : liveInstructions = new Map<HInstruction, int>(),
+        loopMarkers = new Map<HBasicBlock, int>();
 
   /**
    * Remove an instruction from the liveIn set. This method also
    * updates the live interval of [instruction] to contain the new
    * range: [id, / id contained in [liveInstructions] /].
    */
   void remove(HInstruction instruction, int id) {
-    LiveInterval interval = liveIntervals.putIfAbsent(
-        instruction, () => new LiveInterval());
+    LiveInterval interval =
+        liveIntervals.putIfAbsent(instruction, () => new LiveInterval());
     int lastId = liveInstructions[instruction];
     // If [lastId] is null, then this instruction is not being used.
     interval.add(new LiveRange(id, lastId == null ? id : lastId));
     // The instruction is defined at [id].
     interval.start = id;
     liveInstructions.remove(instruction);
   }
 
   /**
    * Add [instruction] to the liveIn set. If the instruction is not
@@ skipping 10 matching lines @@
    * instructions in case they are different between this and [other].
    */
   void mergeWith(LiveEnvironment other) {
     other.liveInstructions.forEach((HInstruction instruction, int existingId) {
       // If both environments have the same instruction id of where
       // [instruction] dies, there is no need to update the live
       // interval of [instruction]. For example the if block and the
       // else block have the same end id for an instruction that is
       // being used in the join block and defined before the if/else.
       if (existingId == endId) return;
-      LiveInterval range = liveIntervals.putIfAbsent(
-          instruction, () => new LiveInterval());
+      LiveInterval range =
+          liveIntervals.putIfAbsent(instruction, () => new LiveInterval());
       range.add(new LiveRange(other.startId, existingId));
       liveInstructions[instruction] = endId;
     });
-    other.loopMarkers.forEach((k, v) { loopMarkers[k] = v; });
+    other.loopMarkers.forEach((k, v) {
+      loopMarkers[k] = v;
+    });
   }
 
   void addLoopMarker(HBasicBlock header, int id) {
     assert(!loopMarkers.containsKey(header));
     loopMarkers[header] = id;
   }
 
   void removeLoopMarker(HBasicBlock header) {
     assert(loopMarkers.containsKey(header));
     loopMarkers.remove(header);
@@ skipping 28 matching lines @@
    */
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
 
   /**
    * The live intervals of instructions.
    */
   final Map<HInstruction, LiveInterval> liveIntervals;
 
   SsaLiveIntervalBuilder(
       this.compiler, this.generateAtUseSite, this.controlFlowOperators)
-    : liveInstructions = new Map<HBasicBlock, LiveEnvironment>(),
-      liveIntervals = new Map<HInstruction, LiveInterval>();
+      : liveInstructions = new Map<HBasicBlock, LiveEnvironment>(),
+        liveIntervals = new Map<HInstruction, LiveInterval>();
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
     if (!liveInstructions[graph.entry].isEmpty) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE, 'LiveIntervalBuilder.');
     }
   }
 
-  void markInputsAsLiveInEnvironment(HInstruction instruction,
-                                     LiveEnvironment environment) {
+  void markInputsAsLiveInEnvironment(
+      HInstruction instruction, LiveEnvironment environment) {
     for (int i = 0, len = instruction.inputs.length; i < len; i++) {
       markAsLiveInEnvironment(instruction.inputs[i], environment);
     }
   }
 
   // Returns the non-HCheck instruction, or the last [HCheck] in the
   // check chain that is not generate at use site.
   //
   // For example:
   //
@@ skipping 11 matching lines @@
   HInstruction checkedInstructionOrNonGenerateAtUseSite(HCheck check) {
     var checked = check.checkedInput;
     while (checked is HCheck) {
       HInstruction next = checked.checkedInput;
       if (generateAtUseSite.contains(next)) break;
       checked = next;
     }
     return checked;
   }
 
-  void markAsLiveInEnvironment(HInstruction instruction,
-                               LiveEnvironment environment) {
+  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) {
         HCheck check = instruction;
         HInstruction checked = checkedInstructionOrNonGenerateAtUseSite(check);
         if (!generateAtUseSite.contains(checked)) {
           environment.add(checked, instructionId);
         }
       }
     }
   }
 
-  void removeFromEnvironment(HInstruction instruction,
-                             LiveEnvironment environment) {
+  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) {
       HCheck check = instruction;
       HInstruction checked = checkedInstructionOrNonGenerateAtUseSite(check);
       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.
@@ skipping 69 matching lines @@
       updateLoopMarker(block);
     }
   }
 
   void updateLoopMarker(HBasicBlock header) {
     LiveEnvironment env = liveInstructions[header];
     int lastId = env.loopMarkers[header];
     // Update all instructions that are liveIns in [header] to have a
     // range that covers the loop.
     env.liveInstructions.forEach((HInstruction instruction, int id) {
-      LiveInterval range = env.liveIntervals.putIfAbsent(
-          instruction, () => new LiveInterval());
+      LiveInterval range =
+          env.liveIntervals.putIfAbsent(instruction, () => new LiveInterval());
       range.loopUpdate(env.startId, lastId);
       env.liveInstructions[instruction] = lastId;
     });
 
     env.removeLoopMarker(header);
 
     // Update all liveIns set to contain the liveIns of [header].
     liveInstructions.forEach((HBasicBlock block, LiveEnvironment other) {
       if (other.loopMarkers.containsKey(header)) {
         env.liveInstructions.forEach((HInstruction instruction, int id) {
           other.liveInstructions[instruction] = id;
         });
         other.removeLoopMarker(header);
-        env.loopMarkers.forEach((k, v) { other.loopMarkers[k] = v; });
+        env.loopMarkers.forEach((k, v) {
+          other.loopMarkers[k] = v;
+        });
       }
     });
   }
 }
 
 /**
  * Represents a copy from one instruction to another. The codegen
  * also uses this class to represent a copy from one variable to
  * another.
  */
@@ skipping 14 matching lines @@
    */
   final List<Copy> copies;
 
   /**
    * Assignments from an instruction that does not need a name (e.g. a
    * constant) to the phi of a successor.
    */
   final List<Copy> assignments;
 
   CopyHandler()
-    : copies = new List<Copy>(),
-      assignments = new List<Copy>();
+      : copies = new List<Copy>(),
+        assignments = new List<Copy>();
 
   void addCopy(HInstruction source, HInstruction destination) {
     copies.add(new Copy(source, destination));
   }
 
   void addAssignment(HInstruction source, HInstruction destination) {
     assignments.add(new Copy(source, destination));
   }
 
   String toString() => 'Copies: $copies, assignments: $assignments';
@@ skipping 16 matching lines @@
    * anywhere by reserving it when we allocate names for instructions.
    */
   final String swapTemp;
 
   String getSwapTemp() {
     allUsedNames.add(swapTemp);
     return swapTemp;
   }
 
   VariableNames()
-    : ownName = new Map<HInstruction, String>(),
-      copyHandlers = new Map<HBasicBlock, CopyHandler>(),
-      allUsedNames = new Set<String>(),
-      swapTemp = 't0';
+      : ownName = new Map<HInstruction, String>(),
+        copyHandlers = new Map<HBasicBlock, CopyHandler>(),
+        allUsedNames = new Set<String>(),
+        swapTemp = 't0';
 
   int get numberOfVariables => allUsedNames.length;
 
   String getName(HInstruction instruction) {
     return ownName[instruction];
   }
 
   CopyHandler getCopyHandler(HBasicBlock block) {
     return copyHandlers[block];
   }
@@ skipping 21 matching lines @@
  * Allocates variable names for instructions, making sure they don't collide.
  */
 class VariableNamer {
   final VariableNames names;
   final Compiler compiler;
   final Set<String> usedNames;
   final List<String> freeTemporaryNames;
   int temporaryIndex = 0;
   static final RegExp regexp = new RegExp('t[0-9]+');
 
-  VariableNamer(LiveEnvironment environment,
-                this.names,
-                this.compiler)
-    : usedNames = new Set<String>(),
-      freeTemporaryNames = new List<String>() {
+  VariableNamer(LiveEnvironment environment, this.names, this.compiler)
+      : usedNames = new Set<String>(),
+        freeTemporaryNames = new List<String>() {
     // [VariableNames.swapTemp] is used when there is a cycle in a copy handler.
     // Therefore we make sure no one uses it.
     usedNames.add(names.swapTemp);
 
     // 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 91 matching lines @@
  * the liveIns set as well as all the live intervals of instructions.
  * It visits the graph in dominator order, so that at each entry of a
  * block, the instructions in its liveIns set have names.
  *
  * When visiting a block, it goes through all instructions. For each
  * instruction, it frees the names of the inputs that die at that
  * instruction, and allocates a name to the instruction. For each phi,
  * it adds a copy to the CopyHandler of the corresponding predecessor.
  */
 class SsaVariableAllocator extends HBaseVisitor {
-
   final Compiler compiler;
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
   final Map<HInstruction, LiveInterval> liveIntervals;
   final Set<HInstruction> generateAtUseSite;
 
   final VariableNames names;
 
-  SsaVariableAllocator(this.compiler,
-                       this.liveInstructions,
-                       this.liveIntervals,
-                       this.generateAtUseSite)
-    : this.names = new VariableNames();
+  SsaVariableAllocator(this.compiler, this.liveInstructions, this.liveIntervals,
+      this.generateAtUseSite)
+      : this.names = new VariableNames();
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
-    VariableNamer namer = new VariableNamer(
-        liveInstructions[block], names, compiler);
+    VariableNamer namer =
+        new VariableNamer(liveInstructions[block], names, compiler);
 
     block.forEachPhi((HPhi phi) {
       handlePhi(phi, namer);
     });
 
     block.forEachInstruction((HInstruction instruction) {
       handleInstruction(instruction, namer);
     });
   }
 
@@ skipping 12 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 freeUsedNamesAt(HInstruction instruction,
-                       HInstruction at,
-                       VariableNamer namer) {
+  void freeUsedNamesAt(
+      HInstruction instruction, HInstruction at, VariableNamer namer) {
     if (needsName(instruction)) {
       if (diesAt(instruction, at)) {
         namer.freeName(instruction);
       }
     } else if (generateAtUseSite.contains(instruction)) {
       // If the instruction is generated at use site, then all its
       // inputs may also die at [at].
       for (int i = 0, len = instruction.inputs.length; i < len; i++) {
         HInstruction input = instruction.inputs[i];
         freeUsedNamesAt(input, at, namer);
@@ skipping 30 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }