*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopsData.java	Mon Mar 20 17:40:14 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopsData.java	Mon Mar 20 17:40:14 2017

*** 1,7 ****
--- 1,7 ----
  /*
!  * Copyright (c) 2012, 2012, Oracle and/or its affiliates. All rights reserved.
!  * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 22,102 ****
--- 22,94 ----
   */
  package org.graalvm.compiler.loop;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.graalvm.compiler.core.common.CollectionsFactory;
  import org.graalvm.compiler.core.common.cfg.Loop;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.Debug.Scope;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.nodes.LoopBeginNode;
  import org.graalvm.compiler.nodes.StructuredGraph;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.cfg.Block;
  import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.util.EconomicMap;
+ import org.graalvm.util.EconomicSet;
  
  public class LoopsData {
  
!     private Map<Loop<Block>, LoopEx> loopToEx = CollectionsFactory.newIdentityMap();
!     private Map<LoopBeginNode, LoopEx> loopBeginToEx = Node.newIdentityMap();
      private ControlFlowGraph cfg;
+     private final EconomicMap<LoopBeginNode, LoopEx> loopBeginToEx = EconomicMap.create(Equivalence.IDENTITY);
!     private final ControlFlowGraph cfg;
!     private final List<LoopEx> loops;
  
      @SuppressWarnings("try")
      public LoopsData(final StructuredGraph graph) {
          try (Scope s = Debug.scope("ControlFlowGraph")) {
              cfg = ControlFlowGraph.compute(graph, true, true, true, true);
          } catch (Throwable e) {
              throw Debug.handle(e);
          }
  
+         assert checkLoopOrder(cfg.getLoops());
+         loops = new ArrayList<>(cfg.getLoops().size());
          for (Loop<Block> loop : cfg.getLoops()) {
              LoopEx ex = new LoopEx(loop, this);
!             loopToEx.put(loop, ex);
!             loops.add(ex);
              loopBeginToEx.put(ex.loopBegin(), ex);
          }
      }
  
      public LoopEx loop(Loop<?> loop) {
          return loopToEx.get(loop);
+     /**
+      * Checks that loops are ordered such that outer loops appear first.
+      */
+     private static boolean checkLoopOrder(Iterable<Loop<Block>> loops) {
+         EconomicSet<Loop<Block>> seen = EconomicSet.create(Equivalence.IDENTITY);
+         for (Loop<Block> loop : loops) {
+             if (loop.getParent() != null && !seen.contains(loop.getParent())) {
+                 return false;
              }
  
      public LoopEx loop(LoopBeginNode loopBegin) {
          return loopBeginToEx.get(loopBegin);
+             seen.add(loop);
          }
  
      public Collection<LoopEx> loops() {
          return loopToEx.values();
+         return true;
      }
  
!     public List<LoopEx> outerFirst() {
!         ArrayList<LoopEx> loops = new ArrayList<>(loops());
          Collections.sort(loops, new Comparator<LoopEx>() {
!     public LoopEx loop(Loop<Block> loop) {
!         return loopBeginToEx.get((LoopBeginNode) loop.getHeader().getBeginNode());
+     }
  
              @Override
              public int compare(LoopEx o1, LoopEx o2) {
                  return o1.loop().getDepth() - o2.loop().getDepth();
+     public LoopEx loop(LoopBeginNode loopBegin) {
+         return loopBeginToEx.get(loopBegin);
      }
          });
+ 
+     public List<LoopEx> loops() {
          return loops;
      }
  
!     public List<LoopEx> innerFirst() {
          ArrayList<LoopEx> loops = new ArrayList<>(loops());
          Collections.sort(loops, new Comparator<LoopEx>() {
  
              @Override
              public int compare(LoopEx o1, LoopEx o2) {
                  return o2.loop().getDepth() - o1.loop().getDepth();
              }
          });
!     public List<LoopEx> outerFirst() {
          return loops;
      }
  
      public Collection<LoopEx> countedLoops() {
          List<LoopEx> counted = new LinkedList<>();