*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/DebugInfoBuilder.java	Mon Mar 20 17:37:43 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/DebugInfoBuilder.java	Mon Mar 20 17:37:43 2017

*** 22,38 ****
--- 22,36 ----
   */
  package org.graalvm.compiler.core.gen;
  
  import java.util.ArrayDeque;
  import java.util.Arrays;
  import java.util.Map;
  import java.util.Queue;
  
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.DebugCounter;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.lir.ConstantValue;
  import org.graalvm.compiler.lir.LIRFrameState;
  import org.graalvm.compiler.lir.LabelRef;
  import org.graalvm.compiler.lir.Variable;
  import org.graalvm.compiler.nodes.ConstantNode;

*** 42,54 ****
--- 40,55 ----
  import org.graalvm.compiler.nodes.util.GraphUtil;
  import org.graalvm.compiler.nodes.virtual.EscapeObjectState;
  import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
  import org.graalvm.compiler.virtual.nodes.MaterializedObjectState;
  import org.graalvm.compiler.virtual.nodes.VirtualObjectState;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.util.EconomicMap;
  
  import jdk.vm.ci.code.BytecodeFrame;
  import jdk.vm.ci.code.VirtualObject;
+ import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.JavaKind;
  import jdk.vm.ci.meta.JavaType;
  import jdk.vm.ci.meta.JavaValue;
  import jdk.vm.ci.meta.ResolvedJavaField;
  import jdk.vm.ci.meta.ResolvedJavaType;

*** 66,77 ****
--- 67,78 ----
      }
  
      private static final JavaValue[] NO_JAVA_VALUES = {};
      private static final JavaKind[] NO_JAVA_KINDS = {};
  
!     protected final Map<VirtualObjectNode, VirtualObject> virtualObjects = Node.newMap();
!     protected final Map<VirtualObjectNode, EscapeObjectState> objectStates = Node.newIdentityMap();
!     protected final EconomicMap<VirtualObjectNode, VirtualObject> virtualObjects = EconomicMap.create(Equivalence.IDENTITY);
!     protected final EconomicMap<VirtualObjectNode, EscapeObjectState> objectStates = EconomicMap.create(Equivalence.IDENTITY);
  
      protected final Queue<VirtualObjectNode> pendingVirtualObjects = new ArrayDeque<>();
  
      public LIRFrameState build(FrameState topState, LabelRef exceptionEdge) {
          assert virtualObjects.size() == 0;

*** 116,127 ****
--- 117,133 ----
                  if (values.length > 0) {
                      VirtualObjectState currentField = (VirtualObjectState) objectStates.get(vobjNode);
                      assert currentField != null;
                      int pos = 0;
                      for (int i = 0; i < entryCount; i++) {
                          if (!currentField.values().get(i).isConstant() || currentField.values().get(i).asJavaConstant().getJavaKind() != JavaKind.Illegal) {
                          ValueNode value = currentField.values().get(i);
+                         if (value == null) {
+                             JavaKind entryKind = vobjNode.entryKind(i);
+                             values[pos] = JavaConstant.defaultForKind(entryKind.getStackKind());
+                             slotKinds[pos] = entryKind.getStackKind();
+                             pos++;
+                         } else if (!value.isConstant() || value.asJavaConstant().getJavaKind() != JavaKind.Illegal) {
                              values[pos] = toJavaValue(value);
                              slotKinds[pos] = toSlotKind(value);
                              pos++;
                          } else {
                              assert currentField.values().get(i - 1).getStackKind() == JavaKind.Double || currentField.values().get(i - 1).getStackKind() == JavaKind.Long : vobjNode + " " + i + " " +

*** 135,145 ****
--- 141,155 ----
                  }
                  assert checkValues(vobjValue.getType(), values, slotKinds);
                  vobjValue.setValues(values, slotKinds);
              }
  
!             virtualObjectsArray = virtualObjects.values().toArray(new VirtualObject[virtualObjects.size()]);
+             int index = 0;
+             for (VirtualObject value : virtualObjects.getValues()) {
+                 virtualObjectsArray[index++] = value;
+             }
              virtualObjects.clear();
          }
          objectStates.clear();
  
          return newLIRFrameState(exceptionEdge, frame, virtualObjectsArray);