Fix access checks in JVMCI

Some methods such as EspressoJVMCIRuntime.lookupType and
EspressoResolvedJavaField.getType shouldn't perform access checks.
The methods in EspressoConstantPool should continue performing access
checks.

Author: gilles-duboscq

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/impl/ClassRegistry.java

@@ -689,6 +689,11 @@ public static void classInModuleOfLoader(ClassLoadingEnv env, Klass klass, boole
         sb.append(loaderDesc(env, meta, klass.getDefiningClassLoader()));
     }
 
+    public static String loaderDesc(ObjectKlass accessingKlass) {
+        EspressoContext context = accessingKlass.getContext();
+        return loaderDesc(context.getClassLoadingEnv(), context.getMeta(), accessingKlass.getDefiningClassLoader());
+    }
+
     private static String loaderDesc(ClassLoadingEnv env, Meta meta, StaticObject loader) {
         if (env.loaderIsBoot(loader)) {
             return "bootstrap";

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/jvmci/JVMCIUtils.java

@@ -31,6 +31,7 @@
 import com.oracle.truffle.espresso.classfile.descriptors.TypeSymbols;
 import com.oracle.truffle.espresso.constantpool.ResolvedConstant;
 import com.oracle.truffle.espresso.constantpool.RuntimeConstantPool;
+import com.oracle.truffle.espresso.impl.ClassRegistry;
 import com.oracle.truffle.espresso.impl.Klass;
 import com.oracle.truffle.espresso.impl.ObjectKlass;
 import com.oracle.truffle.espresso.meta.Meta;
@@ -43,44 +44,45 @@ private JVMCIUtils() {
     }
 
     @TruffleBoundary
-    public static ObjectKlass findInstanceType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, Meta meta) {
+    public static ObjectKlass findInstanceType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, boolean checkAccess, Meta meta) {
         assert !TypeSymbols.isArray(symbol);
         StaticObject loader = accessingKlass.getDefiningClassLoader();
         ObjectKlass klass;
         if (resolve) {
             klass = (ObjectKlass) meta.loadKlassOrFail(symbol, loader, accessingKlass.protectionDomain());
+            assert klass != null : symbol + " in " + ClassRegistry.loaderDesc(accessingKlass);
         } else {
             klass = (ObjectKlass) meta.getRegistries().findLoadedClass(symbol, loader);
         }
-        if (klass != null && !Klass.checkAccess(klass, accessingKlass)) {
+        if (checkAccess && klass != null && !Klass.checkAccess(klass, accessingKlass)) {
             return null;
         }
         return klass;
     }
 
     @TruffleBoundary
-    public static Klass findType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, Meta meta) {
+    public static Klass findType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, boolean checkAccess, Meta meta) {
         if (TypeSymbols.isPrimitive(symbol)) {
             return meta.resolvePrimitive(symbol);
         } else {
-            return findObjectType(symbol, accessingKlass, resolve, meta);
+            return findObjectType(symbol, accessingKlass, resolve, checkAccess, meta);
         }
     }
 
     @TruffleBoundary
-    public static Klass findObjectType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, Meta meta) {
+    public static Klass findObjectType(Symbol<Type> symbol, ObjectKlass accessingKlass, boolean resolve, boolean checkAccess, Meta meta) {
         if (TypeSymbols.isArray(symbol)) {
-            Klass elemental = findType(meta.getTypes().getElementalType(symbol), accessingKlass, resolve, meta);
+            Klass elemental = findType(meta.getTypes().getElementalType(symbol), accessingKlass, resolve, checkAccess, meta);
             if (elemental == null) {
                 return null;
             }
             return elemental.getArrayKlass(TypeSymbols.getArrayDimensions(symbol));
         } else {
-            return findInstanceType(symbol, accessingKlass, resolve, meta);
+            return findInstanceType(symbol, accessingKlass, resolve, checkAccess, meta);
         }
     }
 
-    public static Klass findObjectType(int classIndex, RuntimeConstantPool pool, boolean resolve, Meta meta) {
+    public static Klass findObjectType(int classIndex, RuntimeConstantPool pool, boolean resolve, boolean checkAccess, Meta meta) {
         ResolvedConstant resolvedConstant = pool.peekResolvedOrNull(classIndex, meta);
         if (resolvedConstant != null) {
             if (!resolve && !resolvedConstant.isSuccess()) {
@@ -98,6 +100,6 @@ public static Klass findObjectType(int classIndex, RuntimeConstantPool pool, boo
         if (type == null || TypeSymbols.isPrimitive(type)) {
             return null;
         }
-        return findObjectType(type, pool.getHolder(), resolve, meta);
+        return findObjectType(type, pool.getHolder(), resolve, checkAccess, meta);
     }
 }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/jvmci/Target_com_oracle_truffle_espresso_jvmci_EspressoJVMCIRuntime.java

@@ -130,7 +130,7 @@ private static StaticObject lookupNonPrimitiveType(ByteSequence typeDescriptor,
                 return toJVMCIUnresolvedType(typeDescriptor, createUnresolved, meta);
             }
         }
-        Klass result = findObjectType(symbol, accessingKlass, resolve, meta);
+        Klass result = findObjectType(symbol, accessingKlass, resolve, false, meta);
         if (result == null) {
             assert !resolve;
             return toJVMCIUnresolvedType(symbol, createUnresolved, meta);

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/jvmci/Target_com_oracle_truffle_espresso_jvmci_meta_EspressoConstantPool.java

@@ -296,7 +296,7 @@ private static StaticObject resolvedConstantToJVMCIObjectType(ResolvedConstant r
 
     private static Klass lookupSymbolicHolder(int cpi, RuntimeConstantPool constantPool, Meta meta) {
         int holderClassIndex = constantPool.memberClassIndex(cpi);
-        return findObjectType(holderClassIndex, constantPool, false, meta);
+        return findObjectType(holderClassIndex, constantPool, false, true, meta);
     }
 
     private static Method tryResolveMethod(int methodIndex, Klass symbolicHolder, RuntimeConstantPool constantPool, Meta meta) {
@@ -394,7 +394,7 @@ private static Method tryResolveMethod(int methodIndex, Klass symbolicHolder, Ru
         }
         Klass klass;
         try {
-            klass = findObjectType(classCpi, constantPool, false, meta);
+            klass = findObjectType(classCpi, constantPool, false, true, meta);
         } catch (EspressoException e) {
             throw EspressoError.shouldNotReachHere("findObjectType with resolve=false should never throw", e);
         }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/jvmci/Target_com_oracle_truffle_espresso_jvmci_meta_EspressoResolvedJavaField.java

@@ -110,7 +110,7 @@ static StaticObject doDefault(StaticObject self, StaticObject unresolved,
             assert context.getLanguage().isInternalJVMCIEnabled();
             Meta meta = context.getMeta();
             Field field = (Field) meta.jvmci.HIDDEN_FIELD_MIRROR.getHiddenObject(self);
-            Klass klass = findType(field.getType(), field.getDeclaringKlass(), false, meta);
+            Klass klass = findType(field.getType(), field.getDeclaringKlass(), false, false, meta);
             if (klass != null) {
                 LOGGER.finer(() -> "ERJF.getType0 found " + klass);
                 return toJVMCIType(klass, objectTypeConstructor, arrayTypeConstructor, forBasicType, context, meta);