Do LICM on loop header instructions. Also first instructions that throw in a loop can be LICM'ed.

sdk/lib/_internal/compiler/implementation/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 32 matching lines @@
           // The constant folder affects the types of instructions, so
           // we run the type propagator again. Note that this would
           // not be necessary if types were directly stored on
           // instructions.
           new SsaNonSpeculativeTypePropagator(compiler),
           new SsaCheckInserter(backend, work, context.boundsChecked),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work),
           new SsaNonSpeculativeTypePropagator(compiler),
+          // Run a dead code eliminator before LICM because dead
+          // interceptors are often in the way of LICM'able instructions.
+          new SsaDeadCodeEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(compiler, constantSystem, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
           new SsaConstantFolder(constantSystem, backend, work),
           new SsaSimplifyInterceptors(compiler, constantSystem, work),
           new SsaDeadCodeEliminator()];
       runPhases(graph, phases);
     });
@@ skipping 943 matching lines @@
     for (int i = graph.blocks.length - 1; i >= 0; i--) {
       HBasicBlock block = graph.blocks[i];
       if (block.isLoopHeader()) {
         int changesFlags = loopChangesFlags[block.id];
         HLoopInformation info = block.loopInformation;
         // Iterate over all blocks of this loop. Note that blocks in
         // inner loops are not visited here, but we know they
         // were visited before because we are iterating in post-order.
         // So instructions that are GVN'ed in an inner loop are in their
         // loop entry, and [info.blocks] contains this loop entry.
+        moveLoopInvariantCodeFromBlock(block, block, changesFlags);
         for (HBasicBlock other in info.blocks) {
           moveLoopInvariantCodeFromBlock(other, block, changesFlags);
         }
       }
     }
   }
 
   void moveLoopInvariantCodeFromBlock(HBasicBlock block,
                                       HBasicBlock loopHeader,
                                       int changesFlags) {
     assert(block.parentLoopHeader == loopHeader);
     HBasicBlock preheader = loopHeader.predecessors[0];
     int dependsFlags = SideEffects.computeDependsOnFlags(changesFlags);
     HInstruction instruction = block.first;
+    bool firstInstructionInLoop = block == loopHeader;
     while (instruction != null) {
       HInstruction next = instruction.next;
       if (instruction.useGvn()
-          && !instruction.canThrow()
+          && (!instruction.canThrow() || firstInstructionInLoop)
           && !instruction.sideEffects.dependsOn(dependsFlags)) {
         bool loopInvariantInputs = true;
         List<HInstruction> inputs = instruction.inputs;
         for (int i = 0, length = inputs.length; i < length; i++) {
           if (isInputDefinedAfterDominator(inputs[i], preheader)) {
             loopInvariantInputs = false;
             break;
           }
         }
 
         // If the inputs are loop invariant, we can move the
         // instruction from the current block to the pre-header block.
         if (loopInvariantInputs) {
           block.detach(instruction);
           preheader.moveAtExit(instruction);
+        } else {
+          firstInstructionInLoop = false;
         }
       }
       int oldChangesFlags = changesFlags;
       changesFlags |= instruction.sideEffects.getChangesFlags();
       if (oldChangesFlags != changesFlags) {
         dependsFlags = SideEffects.computeDependsOnFlags(changesFlags);
       }
       instruction = next;
     }
   }
@@ skipping 264 matching lines @@
       // that knows it is not of a specific Type.
     }
 
     for (HIf ifUser in notIfUsers) {
       changeUsesDominatedBy(ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }