Do not generate at use site loop phis. It requires live analysis that we currently don't implement.

frog/leg/ssa/phi_eliminator.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.
 
 class SsaPhiEliminator extends HGraphVisitor {
   HBasicBlock entry;
   HBasicBlock currentBlock;
 
   visitGraph(HGraph graph) {
     entry = graph.entry;
@@ skipping 40 matching lines @@
 
     // We could not get to the definition, just put the store in the
     // predecessor.
     assert(store !== null);
     predecessor.addAtExit(store);
     return store;
   }
 
   visitBasicBlock(HBasicBlock block) {
     currentBlock = block;
-    List<HLoad> loads = <HLoad>[];
     HPhi phi = block.phis.first;
     while (phi != null) {
       HPhi next = phi.next;
-      visitPhi(phi, loads);
+      visitPhi(phi);
       phi = next;
     }
   }
 
-  visitPhi(HPhi phi, List<HLoad> loads) {
+  visitPhi(HPhi phi) {
     assert(phi !== null);
     if (phi.isLogicalOperator()) return;
     HLocal local;
     if (phi.element != null) {
       local = new HLocal(phi.element);
       entry.addAtEntry(local);
       if (phi.element.kind === ElementKind.PARAMETER) {
         // No need to generate the local, so move it out of the
         // graph.
         entry.detach(local);
       }
     } else {
       local = new HLocal(null);
       entry.addAtEntry(local);
     }
 
 
     List<HBasicBlock> predecessors = currentBlock.predecessors;
-    List<HStore> stores = <HStore>[];
 
     for (int i = 0, len = predecessors.length; i < len; i++) {
       HInstruction value = phi.inputs[i];
 
       // Storing a load of itself to a local can be safely eliminated.
       if (value is HLoad && value.dynamic.local === local) continue;
 
       HStore store = addStore(predecessors[i],
                               currentBlock.dominator,
                               local,
                               value);
 
       if (store != null) {
         if (local.declaredBy === local) {
           HBasicBlock storeBlock = store.block;
           // Check if the store occurs in or just after the entry block.
           if (storeBlock === entry || storeBlock === entry.successors[0]) {
             if (phi.element != null &&
                 phi.element.kind !== ElementKind.PARAMETER) {
               entry.detach(local);
             }
             local.declaredBy = store;
           }
         }
-        stores.add(store);
       }
     }
 
     // We propagate the type of the phi to the load instruction rather
     // than the local because we may end up sharing a single local
     // between different phis of different types.
     HLoad load = new HLoad(local, phi.type);
-    loads.add(load);
-
     currentBlock.addAtEntry(load);
     currentBlock.rewrite(phi, load);
     currentBlock.removePhi(phi);
 
-    if (!currentBlock.isLoopHeader() || !hasLoopPhiAsInput(stores, loads)) {
-      load.setGenerateAtUseSite();
-    }
-  }
-
-  bool hasLoopPhiAsInput(List<HStore> stores, List<HLoad> loads) {
-    // [stores] contains the stores of a specific phi.
-    // [loads] contains the phis that were converted to loads.
-    assert(currentBlock.isLoopHeader());
-    for (HStore store in stores) {
-      HInstruction value = store.value;
-      if (value is HPhi && value.block == currentBlock) {
-        return true;
-      } else if (value is HLoad && loads.indexOf(value) != -1) {
-        return true;
-      }
-    }
-    return false;
+    if (!currentBlock.isLoopHeader()) load.setGenerateAtUseSite();
   }
 }