Set up a stub pipline for using the new cps-based ir to generate js.

pkg/compiler/lib/src/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 20 matching lines @@
   }
 
   void optimize(CodegenWorkItem work, HGraph graph) {
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     measure(() {
       SsaDeadCodeEliminator dce;
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial instruction simplification first to optimize
           // some patterns useful for type conversion.
-          new SsaInstructionSimplifier(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaTypeConversionInserter(compiler),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           // After type propagation, more instructions can be
           // simplified.
-          new SsaInstructionSimplifier(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaCheckInserter(backend, work, context.boundsChecked),
-          new SsaInstructionSimplifier(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaCheckInserter(backend, work, context.boundsChecked),
           new SsaTypePropagator(compiler),
           // Run a dead code eliminator before LICM because dead
           // interceptors are often in the way of LICM'able instructions.
-          new SsaDeadCodeEliminator(compiler),
+          new SsaDeadCodeEliminator(compiler, this),
           new SsaGlobalValueNumberer(compiler),
           // After GVN, some instructions might need their type to be
           // updated because they now have different inputs.
           new SsaTypePropagator(compiler),
           new SsaCodeMotion(),
           new SsaLoadElimination(compiler),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
-          new SsaValueRangeAnalyzer(compiler, constantSystem, work),
+          new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
           // Previous optimizations may have generated new
           // opportunities for instruction simplification.
-          new SsaInstructionSimplifier(constantSystem, backend, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaCheckInserter(backend, work, context.boundsChecked),
           new SsaSimplifyInterceptors(compiler, constantSystem, work),
-          dce = new SsaDeadCodeEliminator(compiler),
+          dce = new SsaDeadCodeEliminator(compiler, this),
           new SsaTypePropagator(compiler)];
       runPhases(graph, phases);
       if (dce.eliminatedSideEffects) {
         phases = <OptimizationPhase>[
             new SsaGlobalValueNumberer(compiler),
             new SsaCodeMotion(),
-            new SsaValueRangeAnalyzer(compiler, constantSystem, work),
-            new SsaInstructionSimplifier(constantSystem, backend, work),
+            new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
+            new SsaInstructionSimplifier(constantSystem, backend, this, work),
             new SsaCheckInserter(backend, work, context.boundsChecked),
             new SsaSimplifyInterceptors(compiler, constantSystem, work),
-            new SsaDeadCodeEliminator(compiler)];
+            new SsaDeadCodeEliminator(compiler, this)];
       } else {
         phases = <OptimizationPhase>[
             // Run the simplifier to remove unneeded type checks inserted
             // by type propagation.
-            new SsaInstructionSimplifier(constantSystem, backend, work)];
+            new SsaInstructionSimplifier(constantSystem, backend, this, work)];
       }
       runPhases(graph, phases);
     });
   }
 }
 
 bool isFixedLength(mask, Compiler compiler) {
   ClassWorld classWorld = compiler.world;
   JavaScriptBackend backend = compiler.backend;
   if (mask.isContainer && mask.length != null) {
@@ skipping 18 matching lines @@
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
   final JavaScriptBackend backend;
   final CodegenWorkItem work;
   final ConstantSystem constantSystem;
   HGraph graph;
   Compiler get compiler => backend.compiler;
+  final SsaOptimizerTask optimizer;
 
-  SsaInstructionSimplifier(this.constantSystem, this.backend, this.work);
+  SsaInstructionSimplifier(this.constantSystem,
+                           this.backend,
+                           this.optimizer,
+                           this.work);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
@@ skipping 819 matching lines @@
     if (boundsChecked.contains(node)) return;
     insertBoundsCheck(
         node, node.receiver, graph.addConstantInt(0, backend.compiler));
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final String name = "SsaDeadCodeEliminator";
 
   final Compiler compiler;
+  final SsaOptimizerTask optimizer;
   SsaLiveBlockAnalyzer analyzer;
   bool eliminatedSideEffects = false;
-  SsaDeadCodeEliminator(this.compiler);
+  SsaDeadCodeEliminator(this.compiler, this.optimizer);
 
   HInstruction zapInstructionCache;
   HInstruction get zapInstruction {
     if (zapInstructionCache == null) {
       // A constant with no type does not pollute types at phi nodes.
       ConstantValue constant =
           new DummyConstantValue(const TypeMask.nonNullEmpty());
       zapInstructionCache = analyzer.graph.addConstant(constant, compiler);
     }
     return zapInstructionCache;
@@ skipping 32 matching lines @@
         && instruction.onlyThrowsNSM()
         && hasFollowingThrowingNSM(instruction)) {
       return true;
     }
     return !instruction.canThrow()
            && instruction is !HParameterValue
            && instruction is !HLocalSet;
   }
 
   void visitGraph(HGraph graph) {
-    analyzer = new SsaLiveBlockAnalyzer(graph, compiler);
+    analyzer = new SsaLiveBlockAnalyzer(graph, compiler, optimizer);
     analyzer.analyze();
     visitPostDominatorTree(graph);
     cleanPhis(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     bool isDeadBlock = analyzer.isDeadBlock(block);
     block.isLive = !isDeadBlock;
     // Start from the last non-control flow instruction in the block.
     HInstruction instruction = block.last.previous;
@@ skipping 63 matching lines @@
       if (input == inputs[i]) {
         user.inputs[i] = zapInstruction;
         zapInstruction.usedBy.add(user);
       }
     }
   }
 }
 
 class SsaLiveBlockAnalyzer extends HBaseVisitor {
   final HGraph graph;
-  final Compiler compiler;
   final Set<HBasicBlock> live = new Set<HBasicBlock>();
   final List<HBasicBlock> worklist = <HBasicBlock>[];
+  final SsaOptimizerTask optimizer;
+  final Compiler compiler;
 
-  SsaLiveBlockAnalyzer(this.graph, this.compiler);
+  SsaLiveBlockAnalyzer(this.graph, this.compiler, this.optimizer);
 
-  JavaScriptBackend get backend => compiler.backend;
-  Map<HInstruction, Range> get ranges => backend.optimizer.ranges;
+  Map<HInstruction, Range> get ranges => optimizer.ranges;
 
   bool isDeadBlock(HBasicBlock block) => !live.contains(block);
 
   void analyze() {
     markBlockLive(graph.entry);
     while (!worklist.isEmpty) {
       HBasicBlock live = worklist.removeLast();
       live.last.accept(this);
     }
   }
@@ skipping 1019 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }