Fix interpreter metadata serialization.

Author: rakachan

substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaFieldImpl.java

@@ -29,6 +29,7 @@
 import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.espresso.classfile.ParserField;
 
+import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.UnresolvedJavaType;
 
 public class CremaResolvedJavaFieldImpl extends InterpreterResolvedJavaField implements CremaResolvedJavaField {
@@ -47,6 +48,32 @@ public static CremaResolvedJavaFieldImpl createAtRuntime(InterpreterResolvedObje
         return new CremaResolvedJavaFieldImpl(declaringClass, f, offset);
     }
 
+    @Override
+    public JavaType getType() {
+        /*
+         * For fields created at build-time, the type is set if it is available. We explicitly do
+         * not want to trigger field type resolution at build-time.
+         *
+         * If the resolvedType is null, the type was not included in the image. If we were to
+         * eagerly create a ResolvedJavaType for it, we would force it back in.
+         */
+        if (resolvedType == null) {
+            UnresolvedJavaType unresolvedJavaType = UnresolvedJavaType.create(getSymbolicType().toString());
+            /*
+             * This should not trigger actual class loading. Instead, we query the loader registry
+             * for an already loaded class.
+             */
+            Class<?> cls = CremaSupport.singleton().findLoadedClass(unresolvedJavaType, getDeclaringClass());
+            if (cls == null) {
+                // Not loaded: return the unresolved type
+                return unresolvedJavaType;
+            }
+            resolvedType = (InterpreterResolvedJavaType) DynamicHub.fromClass(cls).getInterpreterType();
+        }
+        return resolvedType;
+    }
+
+    @Override
     public InterpreterResolvedJavaType getResolvedType() {
         if (resolvedType == null) {
             Class<?> cls = CremaSupport.singleton().resolveOrThrow(UnresolvedJavaType.create(getSymbolicType().toString()), getDeclaringClass());

substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterResolvedJavaField.java

@@ -32,8 +32,6 @@
 
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.svm.core.hub.DynamicHub;
-import com.oracle.svm.core.hub.RuntimeClassLoading;
-import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.descriptors.Name;
@@ -116,13 +114,16 @@ public static InterpreterResolvedJavaField createAtBuildTime(AnalysisField origi
     }
 
     public static InterpreterResolvedJavaField createForInterpreter(String name, int modifiers,
-                    InterpreterResolvedJavaType type, InterpreterResolvedObjectType declaringClass,
+                    JavaType type, InterpreterResolvedObjectType declaringClass,
                     int offset,
-                    JavaConstant constant) {
+                    JavaConstant constant,
+                    boolean isWordStorage) {
         MetadataUtil.requireNonNull(type);
         MetadataUtil.requireNonNull(declaringClass);
         Symbol<Name> nameSymbol = SymbolsSupport.getNames().getOrCreate(name);
-        return new InterpreterResolvedJavaField(nameSymbol, type.getSymbolicType(), modifiers, type, declaringClass, offset, constant, type.isWordType());
+        InterpreterResolvedJavaType resolvedType = type instanceof InterpreterResolvedJavaType ? (InterpreterResolvedJavaType) type : null;
+        Symbol<Type> symbolicType = resolvedType == null ? CremaTypeAccess.jvmciNameToType(type.getName()) : resolvedType.getSymbolicType();
+        return new InterpreterResolvedJavaField(nameSymbol, symbolicType, modifiers, resolvedType, declaringClass, offset, constant, isWordStorage);
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
@@ -199,25 +200,8 @@ public JavaType getType() {
          * eagerly create a ResolvedJavaType for it, we would force it back in.
          */
         if (resolvedType == null) {
-            UnresolvedJavaType unresolvedJavaType = UnresolvedJavaType.create(typeSymbol.toString());
-            Class<?> cls = null;
-            /*
-             * Prevent CremaSupport from being reached from other users of
-             * InterpreterResolvedJavaField.
-             */
-            if (RuntimeClassLoading.isSupported()) {
-                /*
-                 * This should not trigger actual class loading. Instead, we query the loader
-                 * registry for an already loaded class.
-                 */
-                cls = CremaSupport.singleton().findLoadedClass(unresolvedJavaType, getDeclaringClass());
-            }
-            if (cls == null) {
-                // Not loaded: return the unresolved type
-                return unresolvedJavaType;
-            }
-            resolvedType = (InterpreterResolvedJavaType) DynamicHub.fromClass(cls).getInterpreterType();
-
+            // Not included. return the unresolved type.
+            return UnresolvedJavaType.create(typeSymbol.toString());
         }
         return resolvedType;
     }

substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/serialization/Serializers.java

@@ -546,12 +546,13 @@ public static ValueSerializer<ReferenceConstant<?>> newReferenceConstantSerializ
     static final ValueSerializer<InterpreterResolvedJavaField> RESOLVED_FIELD = createSerializer(
                     (context, in) -> {
                         String name = context.readReference(in);
-                        InterpreterResolvedJavaType type = context.readReference(in);
+                        JavaType type = context.readReference(in);
                         InterpreterResolvedObjectType declaringClass = context.readReference(in);
                         int modifiers = LEB128.readUnsignedInt(in);
                         int offset = LEB128.readUnsignedInt(in);
                         JavaConstant constant = context.readReference(in);
-                        return InterpreterResolvedJavaField.createForInterpreter(name, modifiers, type, declaringClass, offset, constant);
+                        boolean isWordStorage = in.readBoolean();
+                        return InterpreterResolvedJavaField.createForInterpreter(name, modifiers, type, declaringClass, offset, constant, isWordStorage);
                     },
                     (context, out, value) -> {
                         context.writeReference(out, value.getName());
@@ -565,6 +566,7 @@ public static ValueSerializer<ReferenceConstant<?>> newReferenceConstantSerializ
                         } else {
                             context.writeReference(out, null);
                         }
+                        out.writeBoolean(value.isWordStorage());
                     });
 
     static final ValueSerializer<InterpreterResolvedObjectType> OBJECT_TYPE = createSerializer(