src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/ConstantStringIndexOfSnippets.java

rev 52509 : [mq]: graal2

@@ -29,11 +29,10 @@
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.compiler.api.replacements.Fold.InjectedParameter;
 import org.graalvm.compiler.api.replacements.Snippet;
 import org.graalvm.compiler.api.replacements.Snippet.ConstantParameter;
 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
-import org.graalvm.compiler.core.common.spi.ArrayOffsetProvider;
 import org.graalvm.compiler.debug.DebugHandlersFactory;
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.spi.LoweringTool;
 import org.graalvm.compiler.options.OptionValues;
 import org.graalvm.compiler.phases.util.Providers;

@@ -42,10 +41,11 @@
 import org.graalvm.compiler.replacements.SnippetTemplate.SnippetInfo;
 import org.graalvm.compiler.replacements.nodes.ExplodeLoopNode;
 
 import jdk.vm.ci.code.TargetDescription;
 import jdk.vm.ci.meta.JavaKind;
+import jdk.vm.ci.meta.MetaAccessProvider;
 
 public class ConstantStringIndexOfSnippets implements Snippets {
     public static class Templates extends AbstractTemplates {
 
         private final SnippetInfo indexOfConstant = snippet(ConstantStringIndexOfSnippets.class, "indexOfConstant");

@@ -93,12 +93,12 @@
             args.add("sourceCount", utf16IndexOf.getArgument(1));
             args.addConst("target", utf16IndexOf.getArgument(2));
             args.add("targetCount", utf16IndexOf.getArgument(3));
             args.add("origFromIndex", utf16IndexOf.getArgument(4));
             byte[] targetByteArray = snippetReflection.asObject(byte[].class, utf16IndexOf.getArgument(2).asJavaConstant());
-            args.addConst("md2", md2Utf16(targetByteArray));
-            args.addConst("cache", computeCacheUtf16(targetByteArray));
+            args.addConst("md2", md2Utf16(tool.getMetaAccess(), targetByteArray));
+            args.addConst("cache", computeCacheUtf16(tool.getMetaAccess(), targetByteArray));
             template(utf16IndexOf, args).instantiate(providers.getMetaAccess(), utf16IndexOf, DEFAULT_REPLACER, args);
         }
     }
 
     static int md2(char[] target) {

@@ -149,16 +149,16 @@
             cache |= (1 << (s[i] & 63));
         }
         return cache;
     }
 
-    static int md2Utf16(byte[] target) {
+    static int md2Utf16(MetaAccessProvider metaAccess, byte[] target) {
         int c = target.length / 2;
         if (c == 0) {
             return 0;
         }
-        long base = UnsafeAccess.UNSAFE.arrayBaseOffset(byte[].class);
+        long base = metaAccess.getArrayBaseOffset(JavaKind.Byte);
         char lastChar = UnsafeAccess.UNSAFE.getChar(target, base + (c - 1) * 2);
         int md2 = c;
         for (int i = 0; i < c - 1; i++) {
             char currChar = UnsafeAccess.UNSAFE.getChar(target, base + i * 2);
             if (currChar == lastChar) {

@@ -166,34 +166,34 @@
             }
         }
         return md2;
     }
 
-    static long computeCacheUtf16(byte[] s) {
+    static long computeCacheUtf16(MetaAccessProvider metaAccess, byte[] s) {
         int c = s.length / 2;
         int cache = 0;
         int i;
-        long base = UnsafeAccess.UNSAFE.arrayBaseOffset(byte[].class);
+        long base = metaAccess.getArrayBaseOffset(JavaKind.Byte);
         for (i = 0; i < c - 1; i++) {
             char currChar = UnsafeAccess.UNSAFE.getChar(s, base + i * 2);
             cache |= (1 << (currChar & 63));
         }
         return cache;
     }
 
     @Fold
-    static int byteArrayBaseOffset(@InjectedParameter ArrayOffsetProvider arrayOffsetProvider) {
-        return arrayOffsetProvider.arrayBaseOffset(JavaKind.Byte);
+    static int byteArrayBaseOffset(@InjectedParameter MetaAccessProvider metaAccess) {
+        return metaAccess.getArrayBaseOffset(JavaKind.Byte);
     }
 
     @Fold
-    static int charArrayBaseOffset(@InjectedParameter ArrayOffsetProvider arrayOffsetProvider) {
-        return arrayOffsetProvider.arrayBaseOffset(JavaKind.Char);
+    static int charArrayBaseOffset(@InjectedParameter MetaAccessProvider metaAccess) {
+        return metaAccess.getArrayBaseOffset(JavaKind.Char);
     }
 
     /** Marker value for the {@link InjectedParameter} injected parameter. */
-    static final ArrayOffsetProvider INJECTED = null;
+    static final MetaAccessProvider INJECTED = null;
 
     @Snippet
     public static int indexOfConstant(char[] source, int sourceOffset, int sourceCount,
                     @ConstantParameter char[] target, int targetOffset, int targetCount,
                     int origFromIndex, @ConstantParameter int md2, @ConstantParameter long cache) {