src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/VirtualizerToolImpl.java

rev 52509 : [mq]: graal

*** 26,36 ****
  
  import static org.graalvm.compiler.core.common.GraalOptions.MaximumEscapeAnalysisArrayLength;
  
  import java.util.List;
  
- import org.graalvm.compiler.core.common.spi.ArrayOffsetProvider;
  import org.graalvm.compiler.core.common.spi.ConstantFieldProvider;
  import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodes.ConstantNode;
--- 26,35 ----
*** 95,123 ****
      public DebugContext getDebug() {
          return debug;
      }
  
      @Override
-     public MetaAccessProvider getMetaAccessProvider() {
-         return metaAccess;
-     }
- 
-     @Override
-     public ConstantReflectionProvider getConstantReflectionProvider() {
-         return constantReflection;
-     }
- 
-     @Override
      public ConstantFieldProvider getConstantFieldProvider() {
          return constantFieldProvider;
      }
  
-     @Override
-     public ArrayOffsetProvider getArrayOffsetProvider() {
-         return loweringProvider;
-     }
- 
      public void reset(PartialEscapeBlockState<?> newState, ValueNode newCurrent, FixedNode newPosition, GraphEffectList newEffects) {
          deleted = false;
          state = newState;
          current = newCurrent;
          position = newPosition;
--- 94,107 ----
*** 166,176 ****
              } else if (entryKind == JavaKind.Int && (accessKind == JavaKind.Long || accessKind == JavaKind.Double) && offset % 8 == 0) {
                  /*
                   * Special case: Allow storing a single long or double value into two consecutive
                   * int slots.
                   */
!                 int nextIndex = virtual.entryIndexForOffset(getArrayOffsetProvider(), offset + 4, JavaKind.Int);
                  if (nextIndex != -1) {
                      canVirtualize = true;
                      assert nextIndex == index + 1 : "expected to be sequential";
                      getDebug().log(DebugContext.DETAILED_LEVEL, "virtualizing %s for double word stored in two ints", current);
                  }
--- 150,160 ----
              } else if (entryKind == JavaKind.Int && (accessKind == JavaKind.Long || accessKind == JavaKind.Double) && offset % 8 == 0) {
                  /*
                   * Special case: Allow storing a single long or double value into two consecutive
                   * int slots.
                   */
!                 int nextIndex = virtual.entryIndexForOffset(getMetaAccess(), offset + 4, JavaKind.Int);
                  if (nextIndex != -1) {
                      canVirtualize = true;
                      assert nextIndex == index + 1 : "expected to be sequential";
                      getDebug().log(DebugContext.DETAILED_LEVEL, "virtualizing %s for double word stored in two ints", current);
                  }
*** 208,218 ****
          return false;
      }
  
      private ValueNode getIllegalConstant() {
          if (illegalConstant == null) {
!             illegalConstant = ConstantNode.forConstant(JavaConstant.forIllegal(), getMetaAccessProvider());
              addNode(illegalConstant);
          }
          return illegalConstant;
      }
  
--- 192,202 ----
          return false;
      }
  
      private ValueNode getIllegalConstant() {
          if (illegalConstant == null) {
!             illegalConstant = ConstantNode.forConstant(JavaConstant.forIllegal(), getMetaAccess());
              addNode(illegalConstant);
          }
          return illegalConstant;
      }