*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/ComputeLoopFrequenciesClosure.java	Mon Mar 20 17:39:13 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/ComputeLoopFrequenciesClosure.java	Mon Mar 20 17:39:13 2017

*** 21,32 ****
--- 21,30 ----
   * questions.
   */
  package org.graalvm.compiler.java;
  
  import java.util.List;
  import java.util.Map;
  import java.util.stream.Collectors;
  
  import org.graalvm.compiler.nodes.AbstractBeginNode;
  import org.graalvm.compiler.nodes.AbstractMergeNode;
  import org.graalvm.compiler.nodes.ControlSplitNode;
  import org.graalvm.compiler.nodes.FixedNode;

*** 34,43 ****
--- 32,42 ----
  import org.graalvm.compiler.nodes.LoopExitNode;
  import org.graalvm.compiler.nodes.StructuredGraph;
  import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
  import org.graalvm.compiler.phases.Phase;
  import org.graalvm.compiler.phases.graph.ReentrantNodeIterator;
+ import org.graalvm.util.EconomicMap;
  
  public final class ComputeLoopFrequenciesClosure extends ReentrantNodeIterator.NodeIteratorClosure<Double> {
  
      private static final ComputeLoopFrequenciesClosure INSTANCE = new ComputeLoopFrequenciesClosure();
  

*** 52,76 ****
--- 51,82 ----
      }
  
      @Override
      protected Double merge(AbstractMergeNode merge, List<Double> states) {
          // a merge has the sum of all predecessor probabilities
!         return states.stream().collect(Collectors.summingDouble(d -> d));
!         double result = 0.0;
+         for (double d : states) {
+             result += d;
+         }
+         return result;
      }
  
      @Override
      protected Double afterSplit(AbstractBeginNode node, Double oldState) {
          // a control split splits up the probability
          ControlSplitNode split = (ControlSplitNode) node.predecessor();
          return oldState * split.probability(node);
      }
  
      @Override
!     protected EconomicMap<LoopExitNode, Double> processLoop(LoopBeginNode loop, Double initialState) {
!         EconomicMap<LoopExitNode, Double> exitStates = ReentrantNodeIterator.processLoop(this, loop, 1D).exitStates;
  
!         double exitProbability = exitStates.values().stream().mapToDouble(d -> d).sum();
!         double exitProbability = 0.0;
+         for (double d : exitStates.getValues()) {
+             exitProbability += d;
+         }
          exitProbability = Math.min(1D, exitProbability);
          if (exitProbability < ControlFlowGraph.MIN_PROBABILITY) {
              exitProbability = ControlFlowGraph.MIN_PROBABILITY;
          }
          assert exitProbability <= 1D && exitProbability >= 0D;