Align espresso's JVMCI behvaiour regarding resolution errors to hotspot

The following methods don't throw exceptions that can happen during
resolution and rather return and unresolved result.
* `lookupField`
* `lookupMethod`
* `lookupType`
* `lookupConstant` for class entries
* `loadReferencedType`

Author: gilles-duboscq

espresso/src/com.oracle.truffle.espresso.jvmci/src/com/oracle/truffle/espresso/jvmci/meta/EspressoConstantPool.java

@@ -75,7 +75,13 @@ public void loadReferencedType(int cpi, int opcode, boolean initialize) {
 
     @Override
     public JavaField lookupField(int cpi, ResolvedJavaMethod method, int opcode) {
-        EspressoResolvedJavaField field = lookupResolvedField(cpi, (EspressoResolvedJavaMethod) method, opcode);
+        EspressoResolvedJavaField field;
+        try {
+            field = lookupResolvedField(cpi, (EspressoResolvedJavaMethod) method, opcode);
+        } catch (Throwable t) {
+            // ignore errors that can happen during type resolution
+            field = null;
+        }
         if (field != null) {
             return field;
         }
@@ -90,7 +96,13 @@ public JavaField lookupField(int cpi, ResolvedJavaMethod method, int opcode) {
 
     @Override
     public JavaMethod lookupMethod(int cpi, int opcode, ResolvedJavaMethod caller) {
-        EspressoResolvedJavaMethod method = lookupResolvedMethod(cpi, opcode, (EspressoResolvedJavaMethod) caller);
+        EspressoResolvedJavaMethod method;
+        try {
+            method = lookupResolvedMethod(cpi, opcode, (EspressoResolvedJavaMethod) caller);
+        } catch (Throwable t) {
+            // ignore errors that can happen during type resolution
+            method = null;
+        }
         if (method != null) {
             return method;
         }

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

@@ -50,6 +50,8 @@
 import static com.oracle.truffle.espresso.substitutions.jvmci.Target_com_oracle_truffle_espresso_jvmci_meta_EspressoResolvedInstanceType.toJVMCIField;
 import static com.oracle.truffle.espresso.substitutions.jvmci.Target_com_oracle_truffle_espresso_jvmci_meta_EspressoResolvedInstanceType.toJVMCIMethod;
 
+import java.util.logging.Level;
+
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.espresso.classfile.ConstantPool;
 import com.oracle.truffle.espresso.classfile.JavaKind;
@@ -77,6 +79,7 @@
 import com.oracle.truffle.espresso.meta.Meta;
 import com.oracle.truffle.espresso.nodes.methodhandle.MHInvokeGenericNode;
 import com.oracle.truffle.espresso.runtime.EspressoContext;
+import com.oracle.truffle.espresso.runtime.EspressoException;
 import com.oracle.truffle.espresso.runtime.EspressoLinkResolver;
 import com.oracle.truffle.espresso.runtime.MethodHandleIntrinsics;
 import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
@@ -209,13 +212,12 @@ private static Field tryResolveField(int fieldIndex, Klass symbolicHolder, Runti
         RuntimeConstantPool constantPool = getRuntimeConstantPool(self, meta);
         if (safeTagAt(constantPool, cpi, meta) == ConstantPool.Tag.CLASS) {
             ResolvedConstant resolvedConstant = constantPool.peekResolvedOrNull(cpi, meta);
-            if (resolvedConstant != null) {
-                Klass klass = (Klass) resolvedConstant.value();
-                LOGGER.finer(() -> "ECP.lookupType found " + klass);
-                return toJVMCIObjectType(klass, meta);
-            } else {
+            if (resolvedConstant == null || !resolvedConstant.isSuccess()) {
                 return toJVMCIUnresolvedType(TypeSymbols.nameToType(constantPool.className(cpi)), meta);
             }
+            Klass klass = (Klass) resolvedConstant.value();
+            LOGGER.finer(() -> "ECP.lookupType found " + klass);
+            return toJVMCIObjectType(klass, meta);
         }
         if (safeTagAt(constantPool, cpi, meta) == ConstantPool.Tag.UTF8) {
             return toJVMCIUnresolvedType(TypeSymbols.nameToType(constantPool.utf8At(cpi)), meta);
@@ -367,13 +369,12 @@ private static Method tryResolveMethod(int methodIndex, Klass symbolicHolder, Ru
             case LDC2_W:
                 if (safeTagAt(constantPool, cpi, meta) == ConstantPool.Tag.CLASS) {
                     ResolvedConstant resolvedConstant = constantPool.peekResolvedOrNull(cpi, meta);
-                    if (resolvedConstant != null) {
-                        Klass klass = (Klass) resolvedConstant.value();
-                        LOGGER.finer(() -> "ECP.lookupReferencedType found " + klass);
-                        return toJVMCIObjectType(klass, meta);
-                    } else {
+                    if (resolvedConstant == null || !resolvedConstant.isSuccess()) {
                         return toJVMCIUnresolvedType(TypeSymbols.nameToType(constantPool.className(cpi)), meta);
                     }
+                    Klass klass = (Klass) resolvedConstant.value();
+                    LOGGER.finer(() -> "ECP.lookupReferencedType found " + klass);
+                    return toJVMCIObjectType(klass, meta);
                 }
                 break;
             case GETSTATIC:
@@ -386,14 +387,20 @@ private static Method tryResolveMethod(int methodIndex, Klass symbolicHolder, Ru
             case INVOKEINTERFACE:
                 if (safeTagAt(constantPool, cpi, meta).isMember()) {
                     int holderClassIndex = constantPool.memberClassIndex(cpi);
-                    Klass holderKlass = findObjectType(holderClassIndex, constantPool, false, meta);
-                    if (holderKlass != null) {
-                        LOGGER.finer(() -> "ECP.lookupReferencedType found " + holderKlass);
-                        return toJVMCIObjectType(holderKlass, meta);
-                    } else {
+                    Klass holderKlass;
+                    try {
+                        holderKlass = findObjectType(holderClassIndex, constantPool, false, meta);
+                    } catch (EspressoException e) {
+                        LOGGER.log(Level.FINE, "ECP.lookupReferencedType exception during lookup", e);
+                        holderKlass = null;
+                    }
+                    if (holderKlass == null) {
                         Symbol<Name> holderName = constantPool.memberClassName(cpi);
                         return toJVMCIUnresolvedType(TypeSymbols.nameToType(holderName), meta);
                     }
+                    Klass finalHolderKlass = holderKlass;
+                    LOGGER.finer(() -> "ECP.lookupReferencedType found " + finalHolderKlass);
+                    return toJVMCIObjectType(holderKlass, meta);
                 }
                 break;
         }
@@ -499,15 +506,13 @@ public static boolean loadReferencedType0(StaticObject self, int cpi, int opcode
         }
         switch (tag) {
             case CLASS -> {
-                if (resolvedConstantOrNull != null) {
-                    Klass klass = (Klass) resolvedConstantOrNull.value();
-                    LOGGER.finer(() -> "ECP.lookupConstant found " + klass);
-                    return toJVMCIObjectType(klass, meta);
-                } else if (resolve) {
-                    throw EspressoError.shouldNotReachHere();
-                } else {
+                if (resolvedConstantOrNull == null || !resolvedConstantOrNull.isSuccess()) {
+                    EspressoError.guarantee(!resolve || resolvedConstantOrNull != null, "Should have been resolved");
                     return toJVMCIUnresolvedType(TypeSymbols.nameToType(constantPool.className(cpi)), meta);
                 }
+                Klass klass = (Klass) resolvedConstantOrNull.value();
+                LOGGER.finer(() -> "ECP.lookupConstant found " + klass);
+                return toJVMCIObjectType(klass, meta);
             }
             case STRING -> {
                 return wrapEspressoObjectConstant(constantPool.resolvedStringAt(cpi), meta);