Start compiler refactoring to support more than a single backend.

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2011, 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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
-  SsaOptimizerTask(Compiler compiler) : super(compiler);
+  final JavaScriptBackend backend;
+  SsaOptimizerTask(JavaScriptBackend backend)
+    : this.backend = backend,
+      super(backend.compiler);
   String get name() => 'SSA optimizer';
+  Compiler get compiler() => backend.compiler;
 
   void runPhases(HGraph graph, List<OptimizationPhase> phases) {
     for (OptimizationPhase phase in phases) {
       phase.visitGraph(graph);
       compiler.tracer.traceGraph(phase.name, graph);
     }
   }
 
   void optimize(WorkItem work, HGraph graph) {
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
-          new SsaConstantFolder(compiler),
+          new SsaConstantFolder(backend),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler),
-          new SsaCheckInserter(compiler),
-          new SsaConstantFolder(compiler),
+          new SsaCheckInserter(backend),
+          new SsaConstantFolder(backend),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
           new SsaDeadCodeEliminator()];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
     return measure(() {
       // Run the phases that will generate type guards.
       List<OptimizationPhase> phases = <OptimizationPhase>[
           new SsaSpeculativeTypePropagator(compiler),
           new SsaTypeGuardInserter(work),
           new SsaEnvironmentBuilder(compiler),
           // Change the propagated types back to what they were before we
           // speculatively propagated, so that we can generate the bailout
           // version.
           // Note that we do this even if there were no guards inserted. If a
           // guard is not beneficial enough we don't emit one, but there might
           // still be speculative types on the instructions.
           new SsaTypePropagator(compiler),
           // Then run the [SsaCheckInserter] because the type propagator also
           // propagated types non-speculatively. For example, it might have
           // propagated the type array for a call to the List constructor.
-          new SsaCheckInserter(compiler)];
+          new SsaCheckInserter(backend)];
       runPhases(graph, phases);
       return !work.guards.isEmpty();
     });
   }
 
   void prepareForSpeculativeOptimizations(WorkItem work, HGraph graph) {
     measure(() {
       // In order to generate correct code for the bailout version, we did not
       // propagate types from the instruction to the type guard. We do it
       // now to be able to optimize further.
       work.guards.forEach((HTypeGuard guard) { guard.isOn = true; });
       // We also need to insert range and integer checks for the type
       // guards. Now that they claim to have a certain type, some
       // depending instructions might become builtin (like native array
       // accesses) and need to be checked.
       // Also run the type propagator, to please the codegen in case
       // no other optimization is run.
       runPhases(graph,
-        <OptimizationPhase>[new SsaCheckInserter(compiler),
+        <OptimizationPhase>[new SsaCheckInserter(backend),
                             new SsaTypePropagator(compiler)]);
     });
   }
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaConstantFolder extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaConstantFolder";
-  final Compiler compiler;
+  final JavaScriptBackend backend;
   HGraph graph;
+  Compiler get compiler() => backend.compiler;
 
-  SsaConstantFolder(this.compiler);
+  SsaConstantFolder(this.backend);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
@@ skipping 224 matching lines @@
     List<HInstruction> users = instruction.usedBy;
     int length = users.length;
     for (int i = 0; i < length; i++) {
       if (users[i] is! HBoolify) return false;
     }
     return true;
   }
 
   HInstruction visitRelational(HRelational node) {
     if (allUsersAreBoolifies(node)) {
-      Interceptors interceptors = compiler.builder.interceptors;
+      Interceptors interceptors = backend.builder.interceptors;
       HStatic oldTarget = node.target;
       Element boolifiedInterceptor =
           interceptors.getBoolifiedVersionOf(oldTarget.element);
       if (boolifiedInterceptor !== null) {
         HStatic boolifiedTarget = new HStatic(boolifiedInterceptor);
         // We don't remove the [oldTarget] in case it is used by other
         // instructions. If it is unused it will be treated as dead code and
         // discarded.
         oldTarget.block.addAfter(oldTarget, boolifiedTarget);
         // Remove us as user from the [oldTarget].
@@ skipping 49 matching lines @@
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction === null ? super.visitIdentity(node) : newInstruction;
   }
 
   HInstruction foldBuiltinEqualsCheck(HEquals node) {
     // TODO(floitsch): cache interceptors.
     HInstruction newInstruction = handleIdentityCheck(node);
     if (newInstruction === null) {
       HStatic target = new HStatic(
-          compiler.builder.interceptors.getTripleEqualsInterceptor());
+          backend.builder.interceptors.getTripleEqualsInterceptor());
       node.block.addBefore(node, target);
       return new HIdentity(target, node.left, node.right);
     } else {
       return newInstruction;
     }
   }
 
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
@@ skipping 21 matching lines @@
         // not implement operator=.
         return foldBuiltinEqualsCheck(node);
       }
     }
 
     if (right.isConstantNull()) {
       if (left.propagatedType.isPrimitive()) {
         return graph.addConstantBool(false);
       } else {
         // TODO(floitsch): cache interceptors.
-        Interceptors interceptors = compiler.builder.interceptors;
+        Interceptors interceptors = backend.builder.interceptors;
         Element equalsElement = interceptors.getEqualsInterceptor();
         // If we have a different element than [equalsElement], we
         // don't need to optimize this instruction to use another
         // element: we know the element is either eqNull or eqNullB.
         if (node.element === equalsElement) {
           Element targetElement = interceptors.getEqualsNullInterceptor();
           bool onlyUsedInBoolify = allUsersAreBoolifies(node);
           if (onlyUsedInBoolify) {
             targetElement = interceptors.getBoolifiedVersionOf(targetElement);
           }
@@ skipping 118 matching lines @@
     if (type === null) return node;
     if (!compiler.world.isOnlyFields(type, node.name)) return node;
     return new HFieldSet(node.name, node.inputs[0], node.inputs[1]);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaCheckInserter";
   Element lengthInterceptor;
 
-  SsaCheckInserter(Compiler compiler) {
+  SsaCheckInserter(JavaScriptBackend backend) {
     SourceString lengthString = const SourceString('length');
     lengthInterceptor =
-        compiler.builder.interceptors.getStaticGetInterceptor(lengthString);
+        backend.builder.interceptors.getStaticGetInterceptor(lengthString);
   }
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
@@ skipping 511 matching lines @@
         // the if block terminates. So any use of the instruction
         // after the join block should be changed to the new
         // instruction.
         changeUsesDominatedBy(ifUser.joinBlock, input, convertedType);
       }
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }