--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java	Mon Mar 07 10:54:56 2016 +0100
+++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java	Tue Mar 08 09:17:23 2016 +0100
@@ -27,7 +27,6 @@
 import static jdk.vm.ci.inittimer.InitTimer.timer;
 
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
 import jdk.vm.ci.code.BytecodeFrame;
@@ -357,12 +356,6 @@
     native HotSpotResolvedJavaMethodImpl getResolvedJavaMethodAtSlot(Class<?> holder, int slot);
 
     /**
-     * Gets the flags (including VM internal flags) for the field identified by {@code holder} and
-     * slot number {@code slot} (i.e. {@link Field#slot}).
-     */
-    native int getResolvedJavaFieldFlagsAtSlot(Class<?> holder, int slot);
-
-    /**
      * Gets the maximum absolute offset of a PC relative call to {@code address} from any position
      * in the code cache.
      *

--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java	Mon Mar 07 10:54:56 2016 +0100
+++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java	Tue Mar 08 09:17:23 2016 +0100
@@ -85,11 +85,6 @@
     private Field reflectionMethodSlot = getReflectionSlotField(Method.class);
 
     /**
-     * {@link Field} object of {@link Field#slot}.
-     */
-    private Field reflectionFieldSlot = getReflectionSlotField(Field.class);
-
-    /**
      * {@link Field} object of {@link Constructor#slot}.
      */
     private Field reflectionConstructorSlot = getReflectionSlotField(Constructor.class);
@@ -116,25 +111,22 @@
     }
 
     public ResolvedJavaField lookupJavaField(Field reflectionField) {
-        try {
-            String name = reflectionField.getName();
-            Class<?> fieldHolder = reflectionField.getDeclaringClass();
-            Class<?> fieldType = reflectionField.getType();
-            final int slot = reflectionFieldSlot.getInt(reflectionField);
+        String name = reflectionField.getName();
+        Class<?> fieldHolder = reflectionField.getDeclaringClass();
+        Class<?> fieldType = reflectionField.getType();
+        // java.lang.reflect.Field's modifiers should be enough here since VM internal modifier bits
+        // are not used (yet).
+        final int modifiers = reflectionField.getModifiers();
+        final long offset = Modifier.isStatic(modifiers) ? UNSAFE.staticFieldOffset(reflectionField) : UNSAFE.objectFieldOffset(reflectionField);
 
-            HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
-            final int flags = runtime.getCompilerToVM().getResolvedJavaFieldFlagsAtSlot(fieldHolder, slot);
-            final long offset = Modifier.isStatic(flags) ? UNSAFE.staticFieldOffset(reflectionField) : UNSAFE.objectFieldOffset(reflectionField);
-            JavaType type = runtime.fromClass(fieldType);
+        HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
+        JavaType type = runtime.fromClass(fieldType);
 
-            if (offset != -1) {
-                HotSpotResolvedObjectType resolved = holder;
-                return resolved.createField(name, type, offset, flags);
-            } else {
-                throw new JVMCIError("unresolved field %s", reflectionField);
-            }
-        } catch (IllegalArgumentException | IllegalAccessException e) {
-            throw new JVMCIError(e);
+        if (offset != -1) {
+            HotSpotResolvedObjectType resolved = holder;
+            return resolved.createField(name, type, offset, modifiers);
+        } else {
+            throw new JVMCIError("unresolved field %s", reflectionField);
         }
     }
 

--- a/src/share/vm/jvmci/jvmciCompilerToVM.cpp	Mon Mar 07 10:54:56 2016 +0100
+++ b/src/share/vm/jvmci/jvmciCompilerToVM.cpp	Tue Mar 08 09:17:23 2016 +0100
@@ -179,12 +179,6 @@
   return JNIHandles::make_local(THREAD, result);
 }
 
-C2V_VMENTRY(jint, getResolvedJavaFieldFlagsAtSlot, (JNIEnv *, jobject, jclass holder_handle, jint slot))
-  oop java_class = JNIHandles::resolve(holder_handle);
-  Klass* holder = java_lang_Class::as_Klass(java_class);
-  return InstanceKlass::cast(holder)->field_access_flags(slot);
-}
-
 C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv *, jobject, jobject base, jlong offset))
   methodHandle method;
   oop base_object = JNIHandles::resolve(base);
@@ -1253,7 +1247,6 @@
   {CC"getClassInitializer",                          CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD,                                      FN_PTR(getClassInitializer)},
   {CC"hasFinalizableSubclass",                       CC"("HS_RESOLVED_KLASS")Z",                                                       FN_PTR(hasFinalizableSubclass)},
   {CC"getMaxCallTargetOffset",                       CC"(J)J",                                                                         FN_PTR(getMaxCallTargetOffset)},
-  {CC"getResolvedJavaFieldFlagsAtSlot",              CC"("CLASS"I)I"                 ,                                                 FN_PTR(getResolvedJavaFieldFlagsAtSlot)},
   {CC"getResolvedJavaMethodAtSlot",                  CC"("CLASS"I)"HS_RESOLVED_METHOD,                                                 FN_PTR(getResolvedJavaMethodAtSlot)},
   {CC"getResolvedJavaMethod",                        CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD,                                      FN_PTR(getResolvedJavaMethod)},
   {CC"getConstantPool",                              CC"(Ljava/lang/Object;J)"HS_CONSTANT_POOL,                                        FN_PTR(getConstantPool)},