diff --git a/substratevm/mx.substratevm/mx_substratevm.py b/substratevm/mx.substratevm/mx_substratevm.py
index 2c64c06ddca6..eb5afcd249d4 100644
--- a/substratevm/mx.substratevm/mx_substratevm.py
+++ b/substratevm/mx.substratevm/mx_substratevm.py
@@ -2455,3 +2455,57 @@ def svm_libcontainer_namespace(args):
libcontainer_project = mx.project("com.oracle.svm.native.libcontainer")
for src_dir in libcontainer_project.source_dirs():
mx.command_function("svm_namespace")(args + ["--directory", src_dir , "--namespace", "svm_container"])
+
+@mx.command(suite, 'capnp-compile', usage_msg="Compile Cap'n Proto schema files to source code.")
+def capnp_compile(args):
+ capnpcjava_home = os.environ.get('CAPNPROTOJAVA_HOME')
+ if capnpcjava_home is None or not exists(capnpcjava_home + '/capnpc-java'):
+ mx.abort('Clone and build capnproto/capnproto-java from GitHub and point CAPNPROTOJAVA_HOME to its path.')
+ srcdir = 'src/com.oracle.svm.hosted/resources/'
+ outdir = 'src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/'
+ command = ['capnp', 'compile',
+ '--import-path=' + capnpcjava_home + '/compiler/src/main/schema/',
+ '--output=' + capnpcjava_home + '/capnpc-java:' + outdir,
+ '--src-prefix=' + srcdir,
+ srcdir + 'SharedLayerSnapshotCapnProtoSchema.capnp']
+ mx.run(command)
+ # Remove huge unused schema chunks from generated code
+ outpath = outdir + 'SharedLayerSnapshotCapnProtoSchemaHolder.java' # name specified in schema
+ with open(outpath, 'r') as f:
+ lines = f.readlines()
+ with open(outpath, 'w') as f:
+ f.write(
+"""/*
+ * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+//@formatter:off
+//Checkstyle: stop
+""")
+ for line in lines:
+ if line.startswith("public final class "):
+ f.write('@SuppressWarnings("all")\n')
+ if 'public static final class Schemas {' in line:
+ break
+ f.write(line)
+ f.write('}\n')
diff --git a/substratevm/mx.substratevm/suite.py b/substratevm/mx.substratevm/suite.py
index 0b2b476975d8..427bb744604f 100644
--- a/substratevm/mx.substratevm/suite.py
+++ b/substratevm/mx.substratevm/suite.py
@@ -202,6 +202,15 @@
"path": "mx.substratevm/jar-with-space-in-resource-dir.jar",
"digest": "sha512:270bffd158c92b04b16db147f4ef336dcb4d830bf3503cc25be1227b351597a3254544b3c4a5183dcc53f2f3ab10b282722dbf7f1b5e9d9a2741878a7057eb40",
},
+
+ "CAPNPROTO_RUNTIME": {
+ "digest" : "sha512:94a7776511c344da60a1acdc346c133522a43c239d067d0d5d86c21291e0252a19bd4fa74e4b1d3a93e75dadd41af6557a5d118a1584e39d34c092485ce065b2",
+ "maven" : {
+ "groupId" : "org.capnproto",
+ "artifactId" : "runtime",
+ "version" : "0.1.16",
+ },
+ },
},
"projects": {
@@ -537,6 +546,7 @@
"sourceDirs": ["src"],
"dependencies": [
"com.oracle.svm.common",
+ "CAPNPROTO_RUNTIME"
],
"requires" : [
"jdk.internal.vm.ci"
@@ -1656,6 +1666,9 @@
"java.management": [
"sun.management",
],
+ "org.graalvm.nativeimage.pointsto": [
+ "org.capnproto"
+ ]
},
},
"noMavenJavadoc": True,
@@ -2089,6 +2102,7 @@
"NATIVE_IMAGE_BASE",
],
"exclude": [
+ # "CAPNPROTO_RUNTIME",
],
"moduleInfo" : {
"name" : "org.graalvm.nativeimage.pointsto",
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapConstant.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapConstant.java
index 13448acb5b1c..9151f5162ea5 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapConstant.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapConstant.java
@@ -52,7 +52,7 @@
@Platforms(Platform.HOSTED_ONLY.class)
public abstract class ImageHeapConstant implements JavaConstant, TypedConstant, CompressibleConstant, VMConstant {
- private static final AtomicInteger currentId = new AtomicInteger(0);
+ private static final AtomicInteger currentId = new AtomicInteger(1);
public static final VarHandle isReachableHandle = ReflectionUtil.unreflectField(ConstantData.class, "isReachable", MethodHandles.lookup());
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoader.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoader.java
index 7494e0d1ec54..47ee090ab228 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoader.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoader.java
@@ -24,95 +24,18 @@
*/
package com.oracle.graal.pointsto.heap;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ANALYSIS_PARSED_GRAPH_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARGUMENTS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARGUMENT_IDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARRAY_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CAN_BE_STATICALLY_BOUND_TAG;
import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CLASS_INIT_NAME;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CLASS_JAVA_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CLASS_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CODE_SIZE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CODE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.COMPONENT_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANTS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANTS_TO_RELINK_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANT_TYPE_TAG;
import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTRUCTOR_NAME;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.DATA_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENCLOSING_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENUM_CLASS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENUM_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_ACCESSED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_FOLDED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_READ_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_WRITTEN_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.HUB_IDENTITY_HASH_CODE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IDENTITY_HASH_CODE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IMAGE_HEAP_SIZE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_FIELDS_WITH_SUPER_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INTERFACES_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INTRINSIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_CONSTRUCTOR_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_DIRECT_ROOT_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_ENUM_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_IMPLEMENTATION_INVOKED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INITIALIZED_AT_BUILD_TIME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INITIALIZED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INSTANTIATED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTERFACE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTERNAL_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTRINSIC_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INVOKED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_LINKED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_REACHABLE;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_STATIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_SYNTHETIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_UNSAFE_ALLOCATED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_VAR_ARGS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_VIRTUAL_ROOT_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.LOCATION_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.METHODS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.METHOD_HANDLE_INTRINSIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.MODIFIERS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_CONSTANT_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_FIELD_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_METHOD_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_TYPE_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NOT_MATERIALIZED_CONSTANT;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NULL_POINTER_CONSTANT;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.OBJECT_OFFSET_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.OBJECT_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PARENT_CONSTANT_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PARENT_CONSTANT_INDEX_TAG;
import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PERSISTED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PRIMITIVE_ARRAY_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.RELOCATED_CONSTANT_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.RETURN_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SIMULATED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SOURCE_FILE_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.STATIC_OBJECT_FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.STATIC_PRIMITIVE_FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.STRENGTHENED_GRAPH_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SUPER_CLASS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.TID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.TYPES_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.VALUE_TAG;
import static com.oracle.graal.pointsto.util.AnalysisError.guarantee;
-import java.io.FileInputStream;
import java.io.IOException;
-import java.io.InputStreamReader;
import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.util.Arrays;
@@ -121,13 +44,31 @@
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import org.graalvm.collections.EconomicMap;
-import org.graalvm.collections.MapCursor;
+import java.util.function.ToIntFunction;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.capnproto.ListReader;
+import org.capnproto.PrimitiveList;
+import org.capnproto.ReaderOptions;
+import org.capnproto.Serialize;
+import org.capnproto.StructList;
+import org.capnproto.StructReader;
+import org.capnproto.Text;
+import org.capnproto.TextList;
import com.oracle.graal.pointsto.flow.AnalysisParsedGraph;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ConstantReference;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisField;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisMethod;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisType;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant.Object.Relinking.EnumConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant.Object.Relinking.StringConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.SharedLayerSnapshot;
import com.oracle.graal.pointsto.heap.value.ValueSupplier;
import com.oracle.graal.pointsto.infrastructure.ResolvedSignature;
import com.oracle.graal.pointsto.meta.AnalysisField;
@@ -147,167 +88,11 @@
import jdk.graal.compiler.debug.GraalError;
import jdk.graal.compiler.nodes.EncodedGraph;
import jdk.graal.compiler.util.ObjectCopier;
-import jdk.graal.compiler.util.json.JsonParser;
import jdk.vm.ci.meta.JavaConstant;
-import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.MethodHandleAccessProvider.IntrinsicMethod;
-import jdk.vm.ci.meta.PrimitiveConstant;
import jdk.vm.ci.meta.ResolvedJavaField;
import jdk.vm.ci.meta.ResolvedJavaType;
-/**
- * Loads the base layer persisted by {@link ImageLayerWriter}. The format of the json file is the
- * following:
- *
- *
- * {
- * "next type id": nextTypeId,
- * "next method id": nextMethodId,
- * "next field id": nextFieldId,
- * "static primitive fields": staticPrimitiveFields.id,
- * "static object fields": staticObjectFields.id,
- * "image heap size": imageHeapSize,
- * "constants to relink": [ids...],
- * "types": {
- * typeIdentifier: {
- * "id": id,
- * "fields": [ids...],
- * "hub identityHashCode": System.identityHashCode(hub),
- * "class java name": type.toJavaName(),
- * "class name": type.getName(),
- * "modifiers": modifiers,
- * "is interface": isInterface,
- * "is enum": isEnum,
- * "is initialized": isInitialized,
- * "is initialized at build time": isInitializedAtBuildTime,
- * "is linked": isLinked,
- * "source file name": sourceFileName,
- * "enclosing type": enclosingTid,
- * "component type": componentTid,
- * "super class": superClassTid,
- * "is instantiated": isInstantiated,
- * "is unsafe allocated": isUnsafeAllocated,
- * "is reachable": isReachable,
- * "interfaces": [
- * interfaceTid,
- * ...
- * ],
- * "annotations": [
- * annotationName,
- * ...
- * ]
- * },
- * ...
- * },
- * "methods": {
- * methodIdentifier: {
- * "id": id,
- * ("arguments": [
- * argumentName,
- * ...
- * ],
- * "class name": className,)
- * "tid": tid,
- * "argument ids": [
- * argumentId,
- * ...
- * ],
- * "id": id,
- * "name": name,
- * "return type": returnTypeId,
- * "is varArg": isVarArg,
- * "can be statically bound": canBeStaticallyBound,
- * "modifiers": modifiers,
- * "is constructor": isConstructor,
- * "is synthetic": isSynthetic,
- * "code": code,
- * "code size": codeSize,
- * "method handle intrinsic": methodHandleIntrinsic,
- * "compiled": compiled,
- * "is virtual root method": isVirtualRootMethod,
- * "is direct root method": isDirectRootMethod,
- * "is invoked": isInvoked,
- * "is implementation invoked": isImplementationInvoked,
- * "is intrinsic method": isIntrinsicMethod,
- * "annotations": [
- * annotationName,
- * ...
- * ]
- * },
- * ...
- * },
- * "fields": {
- * tid: {
- * name: {
- * "id": id,
- * "accessed": accessed,
- * "read": read,
- * "written": written,
- * "folded": folded,
- * "is internal": isInternal,
- * "field type": typeId,
- * "modifiers": modifiers,
- * "position": position,
- * "annotations": [
- * annotationName,
- * ...
- * ]
- * (,"class name": className)
- * (,"location": location)
- * },
- * ...
- * },
- * ...
- * },
- * "constants": {
- * id: {
- * "tid": tid,
- * "identityHashCode": identityHashCode,
- * "constant type": constantType,
- * "data": [
- * [constantType, value],
- * ...
- * ],
- * "simulated": simulated
- * (,"object offset": offset)
- * (,"value": string)
- * (,"enum class": enumClass)
- * (,"enum name": enumValue)
- * (,"class id": cid)
- * }
- * },
- * "image singleton objects" : [
- * objectID,
- * "class name",
- * { (key_value_store) }
- * ],
- * "image singleton keys" : [
- * "key class name",
- * persist_flags,
- * objectID
- * ]
- * }
- *
- *
- * For an {@link ImageHeapInstance} or an {@link ImageHeapObjectArray}, the "data" entry contains
- * constant ids, markers from {@link ImageLayerSnapshotUtil} or primitive value, stored in the form
- * of a two elements array. The first element is the constant type, which is the string
- * representation of the kind of the primitive value or a custom tag. The second element is the
- * primitive value, the constant id, the method id or a custom marker. For an
- * {@link ImageHeapPrimitiveArray} it contains the array itself. Interned {@link String} constants
- * are relinked in the extension image using their base layer "value". {@link Enum} values are
- * relinked in the extension image using their "enum class" and "enum name". {@link Class} constants
- * (DynamicHub) are relinked in the extension image using their type id.
- *
- * Relinking a base layer {@link ImageHeapConstant} is finding the corresponding hosted object in
- * the extension image build process and storing it in the constant. This is only done for object
- * that can be created or found using a specific recipe. Those constants are then called parent
- * constants. Some fields of their field values can then be relinked using the value of the hosted
- * object. The produced constants are called child constants, and they have to be consistent across
- * image builds.
- *
- * The "offset object" is the offset of the constant in the heap from the base layer.
- */
public class ImageLayerLoader {
private final Map types = new ConcurrentHashMap<>();
protected final Map methods = new ConcurrentHashMap<>();
@@ -319,17 +104,10 @@ public class ImageLayerLoader {
private final Map baseLayerMethods = new ConcurrentHashMap<>();
private final Map baseLayerFields = new ConcurrentHashMap<>();
- /** Map from the type id to its identifier in the jsonMap. */
- protected final Map typeIdToIdentifier = new HashMap<>();
-
- /** Map from the method id to its identifier in the jsonMap. */
- private final Map methodIdToIdentifier = new HashMap<>();
-
- /** Map from the field id to the information needed to access it in the jsonMap. */
- private final Map fieldIdToIdentifier = new HashMap<>();
-
- record FieldIdentifier(String tid, String name) {
- }
+ /** Map from {@link ImageLayerSnapshotUtil#getTypeDescriptor} to base layer type ids. */
+ private final Map typeDescriptorToBaseLayerId = new HashMap<>();
+ /** Map from {@link ImageLayerSnapshotUtil#getMethodDescriptor} to base layer method ids. */
+ private final Map methodDescriptorToBaseLayerId = new HashMap<>();
protected final Set> heapScannerTasks = ConcurrentHashMap.newKeySet();
private ImageLayerSnapshotUtil imageLayerSnapshotUtil;
@@ -343,11 +121,9 @@ record FieldIdentifier(String tid, String name) {
protected AnalysisMetaAccess metaAccess;
protected HostedValuesProvider hostedValuesProvider;
- protected EconomicMap jsonMap;
+ protected SharedLayerSnapshot.Reader snapshot;
protected FileChannel graphsChannel;
- private long imageHeapSize;
-
public record FilePaths(Path snapshot, Path snapshotGraphs) {
}
@@ -378,14 +154,16 @@ public void setImageLayerLoaderHelper(ImageLayerLoaderHelper imageLayerLoaderHel
/** This code is not thread safe. */
protected void openFilesAndLoadJsonMap() {
assert loadPaths.size() == 1 : "Currently only one path is supported for image layer loading " + loadPaths;
- if (jsonMap == null) {
+ if (snapshot == null) {
for (FilePaths paths : loadPaths) {
try {
graphsChannel = FileChannel.open(paths.snapshotGraphs);
- try (InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(paths.snapshot.toFile()))) {
- Object json = new JsonParser(inputStreamReader).parse();
- jsonMap = cast(json);
+ try (FileChannel ch = FileChannel.open(paths.snapshot)) {
+ MappedByteBuffer bb = ch.map(FileChannel.MapMode.READ_ONLY, ch.position(), ch.size());
+ ReaderOptions opt = new ReaderOptions(Long.MAX_VALUE, ReaderOptions.DEFAULT_READER_OPTIONS.nestingLimit);
+ snapshot = Serialize.read(bb, opt).getRoot(SharedLayerSnapshot.factory);
+ // NOTE: buffer is never unmapped, but is read-only and pages can be evicted
}
} catch (IOException e) {
throw AnalysisError.shouldNotReachHere("Error during image layer snapshot loading", e);
@@ -417,84 +195,88 @@ private void loadLayerAnalysis0() {
* The new ids of the extension image need to be different from the ones from the base
* layer. The start id is set to the next id of the base layer.
*/
- int nextTypeId = get(jsonMap, NEXT_TYPE_ID_TAG);
- universe.setStartTypeId(nextTypeId);
+ universe.setStartTypeId(snapshot.getNextTypeId());
+ universe.setStartMethodId(snapshot.getNextMethodId());
+ universe.setStartFieldId(snapshot.getNextFieldId());
+ ImageHeapConstant.setCurrentId(snapshot.getNextConstantId());
+
+ for (PersistedAnalysisType.Reader typeData : snapshot.getTypes()) {
+ String descriptor = typeData.getDescriptor().toString();
+ typeDescriptorToBaseLayerId.put(descriptor, typeData.getId());
+ }
+
+ for (PersistedAnalysisMethod.Reader methodData : snapshot.getMethods()) {
+ String descriptor = methodData.getDescriptor().toString();
+ methodDescriptorToBaseLayerId.put(descriptor, methodData.getId());
+ }
- int nextMethodId = get(jsonMap, NEXT_METHOD_ID_TAG);
- universe.setStartMethodId(nextMethodId);
+ streamInts(snapshot.getConstantsToRelink()).mapToObj(this::findConstant)
+ .forEach(c -> prepareConstantRelinking(c, c.getIdentityHashCode(), c.getId()));
+ }
- int nextFieldId = get(jsonMap, NEXT_FIELD_ID_TAG);
- universe.setStartFieldId(nextFieldId);
+ private PersistedConstant.Reader findConstant(int id) {
+ return binarySearchUnique(id, snapshot.getConstants(), PersistedConstant.Reader::getId);
+ }
- int nextConstantId = get(jsonMap, NEXT_CONSTANT_ID_TAG);
- ImageHeapConstant.setCurrentId(nextConstantId);
+ private static T binarySearchUnique(int key, StructList.Reader sortedList, ToIntFunction keyExtractor) {
+ int low = 0;
+ int high = sortedList.size() - 1;
- imageHeapSize = Long.parseLong(get(jsonMap, IMAGE_HEAP_SIZE_TAG));
+ int prevMid = -1;
+ int prevKey = 0;
+ while (low <= high) {
+ int mid = (low + high) >>> 1;
+ T midStruct = sortedList.get(mid);
+ int midKey = keyExtractor.applyAsInt(midStruct);
- storeIdToIdentifier(TYPES_TAG, typeIdToIdentifier);
- storeIdToIdentifier(METHODS_TAG, methodIdToIdentifier);
+ assert prevMid == -1 || (mid < prevMid && midKey < prevKey) || (mid > prevMid && midKey > prevKey) : "unsorted or contains duplicates";
- EconomicMap fieldsMap = get(jsonMap, FIELDS_TAG);
- MapCursor fieldsCursor = fieldsMap.getEntries();
- while (fieldsCursor.advance()) {
- EconomicMap typeData = getValue(fieldsCursor);
- MapCursor typeFieldsCursor = typeData.getEntries();
- while (typeFieldsCursor.advance()) {
- EconomicMap fieldData = getValue(typeFieldsCursor);
- int id = get(fieldData, ID_TAG);
- fieldIdToIdentifier.put(id, new FieldIdentifier(fieldsCursor.getKey(), typeFieldsCursor.getKey()));
+ if (midKey < key) {
+ low = mid + 1;
+ } else if (midKey > key) {
+ high = mid - 1;
+ } else {
+ return midStruct;
}
- }
- EconomicMap constantsMap = get(jsonMap, CONSTANTS_TAG);
- List constantsToRelink = get(jsonMap, CONSTANTS_TO_RELINK_TAG);
- for (int id : constantsToRelink) {
- EconomicMap constantData = get(constantsMap, String.valueOf(id));
- int identityHashCode = get(constantData, IDENTITY_HASH_CODE_TAG);
- prepareConstantRelinking(constantData, identityHashCode, id);
+ prevMid = mid;
+ prevKey = midKey;
}
+ return null;
}
- private void storeIdToIdentifier(String tag, Map idToIdentifier) {
- EconomicMap elementsMap = get(jsonMap, tag);
- MapCursor cursor = elementsMap.getEntries();
- while (cursor.advance()) {
- EconomicMap data = getValue(cursor);
- int id = get(data, ID_TAG);
- idToIdentifier.put(id, cursor.getKey());
+ protected void prepareConstantRelinking(PersistedConstant.Reader constantData, int identityHashCode, int id) {
+ if (!constantData.isObject()) {
+ return;
}
- }
- protected void prepareConstantRelinking(EconomicMap constantData, int identityHashCode, int id) {
- String value = get(constantData, VALUE_TAG);
- if (value != null) {
+ PersistedConstant.Object.Relinking.Reader relinking = constantData.getObject().getRelinking();
+ if (relinking.isStringConstant()) {
+ String value = relinking.getStringConstant().getValue().toString();
injectIdentityHashCode(value.intern(), identityHashCode);
stringToConstant.put(value, id);
- }
-
- String className = get(constantData, ENUM_CLASS_TAG);
- if (className != null) {
- Enum enumValue = getEnumValue(constantData);
+ } else if (relinking.isEnumConstant()) {
+ EnumConstant.Reader enumConstant = relinking.getEnumConstant();
+ Enum enumValue = getEnumValue(enumConstant.getEnumClass(), enumConstant.getEnumName());
injectIdentityHashCode(enumValue, identityHashCode);
enumToConstant.put(enumValue, id);
}
}
- private void loadType(EconomicMap typeData) {
- int tid = get(typeData, ID_TAG);
+ private void loadType(PersistedAnalysisType.Reader typeData) {
+ int tid = typeData.getId();
if (imageLayerLoaderHelper.loadType(typeData, tid)) {
return;
}
- String name = get(typeData, CLASS_JAVA_NAME_TAG);
+ String name = typeData.getClassJavaName().toString();
Class clazz = lookupBaseLayerTypeInHostVM(name);
- Integer superClassTid = get(typeData, SUPER_CLASS_TAG);
- ResolvedJavaType superClass = getResolvedJavaType(superClassTid);
+ ResolvedJavaType superClass = getResolvedJavaTypeForBaseLayerId(typeData.getSuperClassTypeId());
- List interfacesIds = get(typeData, INTERFACES_TAG);
- ResolvedJavaType[] interfaces = interfacesIds.stream().map(this::getResolvedJavaType).toList().toArray(new ResolvedJavaType[0]);
+ ResolvedJavaType[] interfaces = streamInts(typeData.getInterfaces())
+ .mapToObj(this::getResolvedJavaTypeForBaseLayerId).toArray(ResolvedJavaType[]::new);
if (clazz != null) {
/*
@@ -514,13 +296,10 @@ private void loadType(EconomicMap typeData) {
*/
BaseLayerType baseLayerType = getBaseLayerType(typeData, tid, superClass, interfaces);
- List instanceFieldIds = get(typeData, INSTANCE_FIELDS_TAG);
- ResolvedJavaField[] instanceFields = instanceFieldIds.stream().map(this::getBaseLayerField).toList().toArray(new ResolvedJavaField[0]);
- baseLayerType.setInstanceFields(instanceFields);
-
- List instanceFieldWithSuperIds = get(typeData, INSTANCE_FIELDS_WITH_SUPER_TAG);
- ResolvedJavaField[] instanceFieldsWithSuper = instanceFieldWithSuperIds.stream().map(this::getBaseLayerField).toList().toArray(new ResolvedJavaField[0]);
- baseLayerType.setInstanceFieldsWithSuper(instanceFieldsWithSuper);
+ baseLayerType.setInstanceFields(streamInts(typeData.getInstanceFieldIds())
+ .mapToObj(this::getBaseLayerField).toArray(ResolvedJavaField[]::new));
+ baseLayerType.setInstanceFieldsWithSuper(streamInts(typeData.getInstanceFieldIdsWithSuper())
+ .mapToObj(this::getBaseLayerField).toArray(ResolvedJavaField[]::new));
AnalysisType type = universe.lookup(baseLayerType);
guarantee(getBaseLayerTypeId(type) == tid, "The base layer type %s is not correctly matched to the id %d", type, tid);
@@ -528,56 +307,45 @@ private void loadType(EconomicMap typeData) {
}
private BaseLayerType getBaseLayerType(int tid) {
- EconomicMap typesMap = get(jsonMap, TYPES_TAG);
- EconomicMap typeData = get(typesMap, typeIdToIdentifier.get(tid));
-
- Integer superClassTid = get(typeData, SUPER_CLASS_TAG);
- ResolvedJavaType superClass = getResolvedJavaType(superClassTid);
-
- List interfacesIds = get(typeData, INTERFACES_TAG);
- ResolvedJavaType[] interfaces = interfacesIds.stream().map(this::getResolvedJavaType).toList().toArray(new ResolvedJavaType[0]);
-
+ PersistedAnalysisType.Reader typeData = findType(tid);
+ ResolvedJavaType superClass = getResolvedJavaTypeForBaseLayerId(typeData.getSuperClassTypeId());
+ ResolvedJavaType[] interfaces = streamInts(typeData.getInterfaces()).mapToObj(this::getResolvedJavaTypeForBaseLayerId).toArray(ResolvedJavaType[]::new);
return getBaseLayerType(typeData, tid, superClass, interfaces);
}
- private BaseLayerType getBaseLayerType(EconomicMap typeData, int tid, ResolvedJavaType superClass, ResolvedJavaType[] interfaces) {
- return baseLayerTypes.computeIfAbsent(tid, typeId -> {
- String className = get(typeData, CLASS_NAME_TAG);
- int modifiers = get(typeData, MODIFIERS_TAG);
- boolean isInterface = get(typeData, IS_INTERFACE_TAG);
- boolean isEnum = get(typeData, IS_ENUM_TAG);
- boolean isInitialized = get(typeData, IS_INITIALIZED_TAG);
- boolean initializedAtBuildTime = get(typeData, IS_INITIALIZED_AT_BUILD_TIME_TAG);
- boolean isLinked = get(typeData, IS_LINKED_TAG);
- String sourceFileName = get(typeData, SOURCE_FILE_NAME_TAG);
-
- Integer enclosingTid = get(typeData, ENCLOSING_TYPE_TAG);
- ResolvedJavaType enclosingType = getResolvedJavaType(enclosingTid);
-
- Integer componentTid = get(typeData, COMPONENT_TYPE_TAG);
- ResolvedJavaType componentType = getResolvedJavaType(componentTid);
-
+ private BaseLayerType getBaseLayerType(PersistedAnalysisType.Reader td, int tid, ResolvedJavaType superClass, ResolvedJavaType[] interfaces) {
+ return baseLayerTypes.computeIfAbsent(tid, (typeId) -> {
+ String className = td.getClassName().toString();
+ String sourceFileName = td.hasSourceFileName() ? td.getSourceFileName().toString() : null;
+ ResolvedJavaType enclosingType = getResolvedJavaTypeForBaseLayerId(td.getEnclosingTypeId());
+ ResolvedJavaType componentType = getResolvedJavaTypeForBaseLayerId(td.getComponentTypeId());
ResolvedJavaType objectType = universe.getOriginalMetaAccess().lookupJavaType(Object.class);
+ Annotation[] annotations = getAnnotations(td.getAnnotationList());
- Annotation[] annotations = getAnnotations(typeData);
-
- return new BaseLayerType(className, tid, modifiers, isInterface, isEnum, isInitialized, initializedAtBuildTime, isLinked, sourceFileName, enclosingType, componentType, superClass,
- interfaces, objectType, annotations);
+ return new BaseLayerType(className, tid, td.getModifiers(), td.getIsInterface(), td.getIsEnum(), td.getIsInitialized(), td.getIsInitializedAtBuildTime(), td.getIsLinked(), sourceFileName,
+ enclosingType, componentType, superClass, interfaces, objectType, annotations);
});
}
- protected Annotation[] getAnnotations(@SuppressWarnings("unused") EconomicMap elementData) {
+ private static IntStream streamInts(PrimitiveList.Int.Reader reader) {
+ return IntStream.range(0, reader.size()).map(reader::get);
+ }
+
+ private static Stream streamStrings(TextList.Reader reader) {
+ return IntStream.range(0, reader.size()).mapToObj(i -> reader.get(i).toString());
+ }
+
+ protected Annotation[] getAnnotations(@SuppressWarnings("unused") StructList.Reader elementData) {
return new Annotation[0];
}
- private ResolvedJavaType getResolvedJavaType(Integer tid) {
- return tid == null ? null : getAnalysisType(tid).getWrapped();
+ private ResolvedJavaType getResolvedJavaTypeForBaseLayerId(int tid) {
+ return (tid == 0) ? null : getAnalysisTypeForBaseLayerId(tid).getWrapped();
}
- public AnalysisType getAnalysisType(Integer tid) {
+ public AnalysisType getAnalysisTypeForBaseLayerId(int tid) {
if (!types.containsKey(tid)) {
- EconomicMap typesMap = get(jsonMap, TYPES_TAG);
- loadType(get(typesMap, typeIdToIdentifier.get(tid)));
+ loadType(findType(tid));
}
guarantee(types.containsKey(tid), "Type with id %d was not correctly loaded.", tid);
/*
@@ -587,6 +355,10 @@ public AnalysisType getAnalysisType(Integer tid) {
return universe.lookup(types.get(tid).getWrapped());
}
+ protected PersistedAnalysisType.Reader findType(int tid) {
+ return binarySearchUnique(tid, snapshot.getTypes(), PersistedAnalysisType.Reader::getId);
+ }
+
/**
* Returns the type id of the given type in the base layer if it exists. This makes the link
* between the base layer and the extension layer as the id is used to determine which constant
@@ -605,39 +377,28 @@ private int getBaseLayerTypeId(AnalysisType type) {
if (type.getWrapped() instanceof BaseLayerType baseLayerType) {
return baseLayerType.getBaseLayerId();
}
- String typeIdentifier = imageLayerSnapshotUtil.getTypeIdentifier(type);
- EconomicMap typeData = getElementData(TYPES_TAG, typeIdentifier);
- if (typeData == null) {
+ String typeDescriptor = imageLayerSnapshotUtil.getTypeDescriptor(type);
+ Integer typeId = typeDescriptorToBaseLayerId.get(typeDescriptor);
+ if (typeId == null) {
/* The type was not reachable in the base image */
return -1;
}
- int id = get(typeData, ID_TAG);
- int hubIdentityHashCode = get(typeData, HUB_IDENTITY_HASH_CODE_TAG);
+ PersistedAnalysisType.Reader typeData = findType(typeId);
+ int id = typeData.getId();
+ int hubIdentityHashCode = typeData.getHubIdentityHashCode();
typeToHubIdentityHashCode.put(id, hubIdentityHashCode);
return id;
}
public void initializeBaseLayerType(AnalysisType type) {
- String typeIdentifier = typeIdToIdentifier.get(type.getId());
- boolean post = true;
- if (typeIdentifier == null) {
- /*
- * This type was not already created when loading the base layer, so the flags can be
- * registered directly.
- */
- post = false;
- typeIdentifier = imageLayerSnapshotUtil.getTypeIdentifier(type);
- }
- EconomicMap typeData = getElementData(TYPES_TAG, typeIdentifier);
- if (typeData != null) {
- boolean isInstantiated = get(typeData, IS_INSTANTIATED);
- boolean isUnsafeAllocated = get(typeData, IS_UNSAFE_ALLOCATED);
- boolean isReachable = get(typeData, IS_REACHABLE);
-
- registerFlag(isInstantiated, post, () -> type.registerAsInstantiated(PERSISTED));
- registerFlag(isUnsafeAllocated, post, () -> type.registerAsUnsafeAllocated(PERSISTED));
- registerFlag(isReachable, post, () -> type.registerAsReachable(PERSISTED));
+ int id = getBaseLayerTypeId(type);
+ if (id == -1) {
+ return;
}
+ PersistedAnalysisType.Reader td = findType(id);
+ registerFlag(td.getIsInstantiated(), true, () -> type.registerAsInstantiated(PERSISTED));
+ registerFlag(td.getIsUnsafeAllocated(), true, () -> type.registerAsUnsafeAllocated(PERSISTED));
+ registerFlag(td.getIsReachable(), true, () -> type.registerAsReachable(PERSISTED));
}
/**
@@ -685,30 +446,28 @@ private static Class lookupPrimitiveClass(String type) {
};
}
- private void loadMethod(EconomicMap methodData) {
- int mid = get(methodData, ID_TAG);
+ private void loadMethod(PersistedAnalysisMethod.Reader methodData) {
+ int mid = methodData.getId();
if (imageLayerLoaderHelper.loadMethod(methodData, mid)) {
return;
}
- int tid = get(methodData, TID_TAG);
- AnalysisType type = getAnalysisType(tid);
+ int tid = methodData.getDeclaringTypeId();
+ AnalysisType type = getAnalysisTypeForBaseLayerId(tid);
- List parameterTypeIds = get(methodData, ARGUMENT_IDS_TAG);
- AnalysisType[] parameterTypes = parameterTypeIds.stream().map(this::getAnalysisType).toList().toArray(new AnalysisType[0]);
+ AnalysisType[] parameterTypes = streamInts(methodData.getArgumentTypeIds()).mapToObj(this::getAnalysisTypeForBaseLayerId).toArray(AnalysisType[]::new);
- AnalysisType returnType = getAnalysisType(get(methodData, RETURN_TYPE_TAG));
+ AnalysisType returnType = getAnalysisTypeForBaseLayerId(methodData.getReturnTypeId());
- String name = get(methodData, NAME_TAG);
- String className = get(methodData, CLASS_NAME_TAG);
- if (className != null) {
- List arguments = get(methodData, ARGUMENTS_TAG);
+ String name = methodData.getName().toString();
+ if (methodData.hasClassName()) {
+ String className = methodData.getClassName().toString();
Executable method = null;
Class clazz = lookupBaseLayerTypeInHostVM(className);
if (clazz != null) {
- Class[] argumentClasses = arguments.stream().map(this::lookupBaseLayerTypeInHostVM).toList().toArray(new Class[0]);
+ Class[] argumentClasses = streamStrings(methodData.getArgumentClassNames()).map(this::lookupBaseLayerTypeInHostVM).toArray(Class[]::new);
method = lookupMethodByReflection(name, clazz, argumentClasses);
}
@@ -720,7 +479,7 @@ private void loadMethod(EconomicMap methodData) {
}
}
- Class[] argumentClasses = Arrays.stream(parameterTypes).map(AnalysisType::getJavaClass).toList().toArray(new Class[0]);
+ Class[] argumentClasses = Arrays.stream(parameterTypes).map(AnalysisType::getJavaClass).toArray(Class[]::new);
Executable method = lookupMethodByReflection(name, type.getJavaClass(), argumentClasses);
if (method != null) {
@@ -759,32 +518,26 @@ public static Executable lookupMethodByReflection(String name, Class clazz, C
}
}
- private void createBaseLayerMethod(EconomicMap methodData, int mid, String name, AnalysisType[] parameterTypes, AnalysisType returnType) {
- AnalysisType type = getAnalysisType(get(methodData, TID_TAG));
+ private void createBaseLayerMethod(PersistedAnalysisMethod.Reader md, int mid, String name, AnalysisType[] parameterTypes, AnalysisType returnType) {
+ AnalysisType type = getAnalysisTypeForBaseLayerId(md.getDeclaringTypeId());
ResolvedSignature signature = ResolvedSignature.fromArray(parameterTypes, returnType);
- boolean canBeStaticallyBound = get(methodData, CAN_BE_STATICALLY_BOUND_TAG);
- boolean isConstructor = get(methodData, IS_CONSTRUCTOR_TAG);
- int modifiers = get(methodData, MODIFIERS_TAG);
- boolean isSynthetic = get(methodData, IS_SYNTHETIC_TAG);
- boolean isVarArgs = get(methodData, IS_VAR_ARGS_TAG);
- List codeEncoding = get(methodData, CODE_TAG);
- byte[] code = codeEncoding == null ? null : getBytes(codeEncoding);
- int codeSize = get(methodData, CODE_SIZE_TAG);
- String methodHandleIntrinsicName = get(methodData, METHOD_HANDLE_INTRINSIC_TAG);
- IntrinsicMethod methodHandleIntrinsic = methodHandleIntrinsicName == null ? null : IntrinsicMethod.valueOf(methodHandleIntrinsicName);
- Annotation[] annotations = getAnnotations(methodData);
-
- baseLayerMethods.computeIfAbsent(mid, methodId -> new BaseLayerMethod(mid, type, name, isVarArgs, signature, canBeStaticallyBound, isConstructor, modifiers, isSynthetic, code, codeSize,
- methodHandleIntrinsic, annotations));
+ byte[] code = md.hasCode() ? md.getCode().toArray() : null;
+ IntrinsicMethod methodHandleIntrinsic = !md.hasMethodHandleIntrinsicName() ? null
+ : IntrinsicMethod.valueOf(md.getMethodHandleIntrinsicName().toString());
+ Annotation[] annotations = getAnnotations(md.getAnnotationList());
+
+ baseLayerMethods.computeIfAbsent(mid,
+ methodId -> new BaseLayerMethod(mid, type, name, md.getIsVarArgs(), signature, md.getCanBeStaticallyBound(), md.getIsConstructor(),
+ md.getModifiers(), md.getIsSynthetic(), code, md.getCodeSize(), methodHandleIntrinsic, annotations));
BaseLayerMethod baseLayerMethod = baseLayerMethods.get(mid);
universe.lookup(baseLayerMethod);
}
- public AnalysisMethod getAnalysisMethod(int mid) {
+ public AnalysisMethod getAnalysisMethodForBaseLayerId(int mid) {
if (!methods.containsKey(mid)) {
- EconomicMap methodsMap = get(jsonMap, METHODS_TAG);
- loadMethod(get(methodsMap, methodIdToIdentifier.get(mid)));
+ PersistedAnalysisMethod.Reader methodData = findMethod(mid);
+ loadMethod(methodData);
}
AnalysisMethod analysisMethod = methods.get(mid);
@@ -792,6 +545,10 @@ public AnalysisMethod getAnalysisMethod(int mid) {
return analysisMethod;
}
+ private PersistedAnalysisMethod.Reader findMethod(int mid) {
+ return binarySearchUnique(mid, snapshot.getMethods(), PersistedAnalysisMethod.Reader::getId);
+ }
+
/**
* Returns the method id of the given method in the base layer if it exists. This makes the link
* between the base layer and the extension layer as the id is used to determine the method used
@@ -805,12 +562,15 @@ private int getBaseLayerMethodId(AnalysisMethod analysisMethod) {
if (analysisMethod.getWrapped() instanceof BaseLayerMethod baseLayerMethod) {
return baseLayerMethod.getBaseLayerId();
}
- EconomicMap methodData = getMethodData(analysisMethod);
- if (methodData == null || methods.containsKey(analysisMethod.getId())) {
+ if (methods.containsKey(analysisMethod.getId())) {
+ return -1;
+ }
+ PersistedAnalysisMethod.Reader methodData = getMethodData(analysisMethod);
+ if (methodData == null) {
/* The method was not reachable in the base image */
return -1;
}
- return get(methodData, ID_TAG);
+ return methodData.getId();
}
public void addBaseLayerMethod(AnalysisMethod analysisMethod) {
@@ -821,18 +581,12 @@ public void initializeBaseLayerMethod(AnalysisMethod analysisMethod) {
initializeBaseLayerMethod(analysisMethod, getMethodData(analysisMethod));
}
- protected void initializeBaseLayerMethod(AnalysisMethod analysisMethod, EconomicMap methodData) {
- boolean isVirtualRootMethod = get(methodData, IS_VIRTUAL_ROOT_METHOD);
- boolean isDirectRootMethod = get(methodData, IS_DIRECT_ROOT_METHOD);
- boolean isInvoked = get(methodData, IS_INVOKED);
- boolean isImplementationInvoked = get(methodData, IS_IMPLEMENTATION_INVOKED);
- boolean isIntrinsicMethod = get(methodData, IS_INTRINSIC_METHOD);
-
- registerFlag(isVirtualRootMethod, true, () -> analysisMethod.registerAsVirtualRootMethod(PERSISTED));
- registerFlag(isDirectRootMethod, true, () -> analysisMethod.registerAsDirectRootMethod(PERSISTED));
- registerFlag(isInvoked, true, () -> analysisMethod.registerAsInvoked(PERSISTED));
- registerFlag(isImplementationInvoked, true, () -> analysisMethod.registerAsImplementationInvoked(PERSISTED));
- registerFlag(isIntrinsicMethod, true, () -> analysisMethod.registerAsIntrinsicMethod(PERSISTED));
+ protected void initializeBaseLayerMethod(AnalysisMethod analysisMethod, PersistedAnalysisMethod.Reader md) {
+ registerFlag(md.getIsVirtualRootMethod(), true, () -> analysisMethod.registerAsVirtualRootMethod(PERSISTED));
+ registerFlag(md.getIsDirectRootMethod(), true, () -> analysisMethod.registerAsDirectRootMethod(PERSISTED));
+ registerFlag(md.getIsInvoked(), true, () -> analysisMethod.registerAsInvoked(PERSISTED));
+ registerFlag(md.getIsImplementationInvoked(), true, () -> analysisMethod.registerAsImplementationInvoked(PERSISTED));
+ registerFlag(md.getIsIntrinsicMethod(), true, () -> analysisMethod.registerAsIntrinsicMethod(PERSISTED));
}
/**
@@ -841,14 +595,13 @@ protected void initializeBaseLayerMethod(AnalysisMethod analysisMethod, Economic
* implementation.
*/
public boolean hasAnalysisParsedGraph(AnalysisMethod analysisMethod) {
- EconomicMap methodData = getMethodData(analysisMethod);
- return get(methodData, ANALYSIS_PARSED_GRAPH_TAG) != null;
+ return getMethodData(analysisMethod).hasAnalysisGraphLocation();
}
public AnalysisParsedGraph getAnalysisParsedGraph(AnalysisMethod analysisMethod) {
- EconomicMap methodData = getMethodData(analysisMethod);
- byte[] encodedAnalyzedGraph = readEncodedGraph(methodData, ANALYSIS_PARSED_GRAPH_TAG);
- Boolean intrinsic = get(methodData, INTRINSIC_TAG);
+ PersistedAnalysisMethod.Reader methodData = getMethodData(analysisMethod);
+ byte[] encodedAnalyzedGraph = readEncodedGraph(methodData.getAnalysisGraphLocation().toString());
+ boolean intrinsic = methodData.getAnalysisGraphIsIntrinsic();
EncodedGraph analyzedGraph = (EncodedGraph) ObjectCopier.decode(imageLayerSnapshotUtil.getGraphDecoder(this, analysisMethod, universe.getSnippetReflection()), encodedAnalyzedGraph);
if (hasStrengthenedGraph(analysisMethod)) {
throw AnalysisError.shouldNotReachHere("Strengthened graphs are not supported until late loading is implemented.");
@@ -857,8 +610,7 @@ public AnalysisParsedGraph getAnalysisParsedGraph(AnalysisMethod analysisMethod)
return new AnalysisParsedGraph(analyzedGraph, intrinsic);
}
- private byte[] readEncodedGraph(EconomicMap methodData, String elementIdentifier) {
- String location = get(methodData, elementIdentifier);
+ private byte[] readEncodedGraph(String location) {
int closingBracketAt = location.length() - 1;
AnalysisError.guarantee(location.charAt(0) == '@' && location.charAt(closingBracketAt) == ']', "Location must start with '@' and end with ']': %s", location);
int openingBracketAt = location.indexOf('[', 1, closingBracketAt);
@@ -881,13 +633,12 @@ private byte[] readEncodedGraph(EconomicMap methodData, String e
}
public boolean hasStrengthenedGraph(AnalysisMethod analysisMethod) {
- EconomicMap methodData = getMethodData(analysisMethod);
- return get(methodData, STRENGTHENED_GRAPH_TAG) != null;
+ return getMethodData(analysisMethod).hasStrengthenedGraphLocation();
}
public void setStrengthenedGraph(AnalysisMethod analysisMethod) {
- EconomicMap methodData = getMethodData(analysisMethod);
- byte[] encodedAnalyzedGraph = readEncodedGraph(methodData, STRENGTHENED_GRAPH_TAG);
+ PersistedAnalysisMethod.Reader methodData = getMethodData(analysisMethod);
+ byte[] encodedAnalyzedGraph = readEncodedGraph(methodData.getStrengthenedGraphLocation().toString());
EncodedGraph analyzedGraph = (EncodedGraph) ObjectCopier.decode(imageLayerSnapshotUtil.getGraphDecoder(this, analysisMethod, universe.getSnippetReflection()), encodedAnalyzedGraph);
afterGraphDecodeHook(analyzedGraph);
analysisMethod.setAnalyzedGraph(analyzedGraph);
@@ -902,21 +653,19 @@ protected static int getId(String line) {
return Integer.parseInt(line.split(" = ")[1]);
}
- private EconomicMap getMethodData(AnalysisMethod analysisMethod) {
- String name;
- int id = analysisMethod.getId();
- if (methodIdToIdentifier.containsKey(id)) {
- name = methodIdToIdentifier.get(id);
- } else {
- name = imageLayerSnapshotUtil.getMethodIdentifier(analysisMethod);
+ private PersistedAnalysisMethod.Reader getMethodData(AnalysisMethod analysisMethod) {
+ if (analysisMethod.getWrapped() instanceof BaseLayerMethod m) {
+ return findMethod(m.getBaseLayerId());
}
- return getElementData(METHODS_TAG, name);
+ String descriptor = imageLayerSnapshotUtil.getMethodDescriptor(analysisMethod);
+ Integer id = methodDescriptorToBaseLayerId.get(descriptor);
+ return (id != null) ? findMethod(id) : null;
}
- private void loadField(FieldIdentifier fieldIdentifier, EconomicMap fieldData) {
- AnalysisType declaringClass = getAnalysisType(Integer.parseInt(fieldIdentifier.tid));
- String className = get(fieldData, CLASS_NAME_TAG);
- int id = get(fieldData, ID_TAG);
+ private void loadField(PersistedAnalysisField.Reader fieldData) {
+ AnalysisType declaringClass = getAnalysisTypeForBaseLayerId(fieldData.getDeclaringTypeId());
+ String className = fieldData.hasClassName() ? fieldData.getClassName().toString() : null;
+ int id = fieldData.getId();
Class clazz = className != null ? lookupBaseLayerTypeInHostVM(className) : declaringClass.getJavaClass();
if (clazz == null) {
@@ -925,14 +674,13 @@ private void loadField(FieldIdentifier fieldIdentifier, EconomicMap fieldsMap = get(jsonMap, FIELDS_TAG);
- EconomicMap fieldData = get(get(fieldsMap, fieldIdentifier.tid), fieldIdentifier.name);
+ PersistedAnalysisField.Reader fieldData = findField(id);
- BaseLayerType declaringClass = getBaseLayerType(Integer.parseInt(fieldIdentifier.tid));
- ResolvedJavaType type = getResolvedJavaType(get(fieldData, FIELD_TYPE_TAG));
+ BaseLayerType declaringClass = getBaseLayerType(fieldData.getDeclaringTypeId());
+ ResolvedJavaType type = getResolvedJavaTypeForBaseLayerId(fieldData.getTypeId());
- return getBaseLayerField(fieldIdentifier, fieldData, id, declaringClass, type);
+ return getBaseLayerField(fieldData, id, declaringClass, type);
}
- private BaseLayerField getBaseLayerField(FieldIdentifier fieldIdentifier, EconomicMap fieldData, int id, ResolvedJavaType declaringClass, ResolvedJavaType type) {
+ private BaseLayerField getBaseLayerField(PersistedAnalysisField.Reader fd, int id, ResolvedJavaType declaringClass, ResolvedJavaType type) {
return baseLayerFields.computeIfAbsent(id,
- fid -> new BaseLayerField(id, fieldIdentifier.name, declaringClass, type, get(fieldData, IS_INTERNAL_TAG), get(fieldData, IS_SYNTHETIC_TAG), get(fieldData, MODIFIERS_TAG),
- getAnnotations(fieldData)));
+ fid -> new BaseLayerField(id, fd.getName().toString(), declaringClass, type, fd.getIsInternal(),
+ fd.getIsSynthetic(), fd.getModifiers(), getAnnotations(fd.getAnnotationList())));
}
- public AnalysisField getAnalysisField(int fid) {
+ public AnalysisField getAnalysisFieldForBaseLayerId(int fid) {
if (!fields.containsKey(fid)) {
- FieldIdentifier fieldIdentifier = fieldIdToIdentifier.get(fid);
- EconomicMap fieldsMap = get(jsonMap, FIELDS_TAG);
- loadField(fieldIdentifier, get(get(fieldsMap, fieldIdentifier.tid), fieldIdentifier.name));
+ loadField(findField(fid));
}
AnalysisField analysisField = fields.get(fid);
@@ -981,6 +725,10 @@ public AnalysisField getAnalysisField(int fid) {
return analysisField;
}
+ private PersistedAnalysisField.Reader findField(int fid) {
+ return binarySearchUnique(fid, snapshot.getFields(), PersistedAnalysisField.Reader::getId);
+ }
+
/**
* Returns the field id of the given field in the base layer if it exists. This makes the link
* between the base layer and the extension image as the id allows to set the flags of the
@@ -994,12 +742,12 @@ private int getBaseLayerFieldId(AnalysisField analysisField) {
if (analysisField.wrapped instanceof BaseLayerField baseLayerField) {
return baseLayerField.getBaseLayerId();
}
- EconomicMap fieldData = getFieldData(analysisField);
+ PersistedAnalysisField.Reader fieldData = getFieldData(analysisField);
if (fieldData == null) {
/* The field was not reachable in the base image */
return -1;
}
- return get(fieldData, ID_TAG);
+ return fieldData.getId();
}
public void addBaseLayerField(AnalysisField analysisField) {
@@ -1007,36 +755,48 @@ public void addBaseLayerField(AnalysisField analysisField) {
}
public void initializeBaseLayerField(AnalysisField analysisField) {
- EconomicMap fieldData = getFieldData(analysisField);
+ PersistedAnalysisField.Reader fieldData = getFieldData(analysisField);
assert fieldData != null : "The field should be in the base layer";
- Integer location = get(fieldData, LOCATION_TAG);
- if (location != null) {
+ int location = fieldData.getLocation();
+ if (location != 0) {
fieldLocations.put(analysisField, location);
}
- boolean isAccessed = get(fieldData, FIELD_ACCESSED_TAG);
- boolean isRead = get(fieldData, FIELD_READ_TAG);
- boolean isWritten = get(fieldData, FIELD_WRITTEN_TAG);
- boolean isFolded = get(fieldData, FIELD_FOLDED_TAG);
-
+ boolean isAccessed = fieldData.getIsAccessed();
+ boolean isRead = fieldData.getIsRead();
if (!analysisField.isStatic() && (isAccessed || isRead)) {
analysisField.getDeclaringClass().getInstanceFields(true);
}
registerFlag(isAccessed, true, () -> analysisField.registerAsAccessed(PERSISTED));
registerFlag(isRead, true, () -> analysisField.registerAsRead(PERSISTED));
- registerFlag(isWritten, true, () -> analysisField.registerAsWritten(PERSISTED));
- registerFlag(isFolded, true, () -> analysisField.registerAsFolded(PERSISTED));
+ registerFlag(fieldData.getIsWritten(), true, () -> analysisField.registerAsWritten(PERSISTED));
+ registerFlag(fieldData.getIsFolded(), true, () -> analysisField.registerAsFolded(PERSISTED));
}
- protected EconomicMap getFieldData(AnalysisField analysisField) {
- int tid = analysisField.getDeclaringClass().getId();
- EconomicMap typeFieldsMap = getElementData(FIELDS_TAG, Integer.toString(tid));
- if (typeFieldsMap == null) {
- /* The type has no reachable field */
+ protected PersistedAnalysisField.Reader getFieldData(AnalysisField analysisField) {
+ if (analysisField.wrapped instanceof BaseLayerField baseLayerField) {
+ return findField(baseLayerField.getBaseLayerId());
+ }
+ String declTypeDescriptor = imageLayerSnapshotUtil.getTypeDescriptor(analysisField.getDeclaringClass());
+ Integer declTypeId = typeDescriptorToBaseLayerId.get(declTypeDescriptor);
+ if (declTypeId == null) {
return null;
}
- return get(typeFieldsMap, analysisField.getName());
+ PersistedAnalysisType.Reader typeData = findType(declTypeId);
+ PrimitiveList.Int.Reader fieldIds;
+ if (analysisField.isStatic()) {
+ fieldIds = typeData.getStaticFieldIds();
+ } else {
+ fieldIds = typeData.getInstanceFieldIds();
+ }
+ for (int i = 0; i < fieldIds.size(); i++) {
+ PersistedAnalysisField.Reader fieldData = findField(fieldIds.get(i));
+ if (fieldData != null && analysisField.getName().equals(fieldData.getName().toString())) {
+ return fieldData;
+ }
+ }
+ return null;
}
private void registerFlag(boolean flag, boolean post, Runnable runnable) {
@@ -1066,27 +826,26 @@ public void executeHeapScannerTasks() {
* underlying host VM, found by querying the parent object that made this constant reachable
* (see {@link ImageLayerLoader#getReachableHostedValue(ImageHeapConstant, int)}).
*/
- protected ImageHeapConstant getOrCreateConstant(EconomicMap constantsMap, int id, JavaConstant parentReachableHostedObjectCandidate) {
+ protected ImageHeapConstant getOrCreateConstant(int id, JavaConstant parentReachableHostedObjectCandidate) {
if (constants.containsKey(id)) {
return constants.get(id);
}
- EconomicMap baseLayerConstant = get(constantsMap, Integer.toString(id));
+ PersistedConstant.Reader baseLayerConstant = findConstant(id);
if (baseLayerConstant == null) {
throw GraalError.shouldNotReachHere("The constant was not reachable in the base image");
}
- int tid = get(baseLayerConstant, TID_TAG);
- AnalysisType type = getAnalysisType(tid);
+ AnalysisType type = getAnalysisTypeForBaseLayerId(baseLayerConstant.getTypeId());
- String objectOffset = get(baseLayerConstant, OBJECT_OFFSET_TAG);
- int identityHashCode = get(baseLayerConstant, IDENTITY_HASH_CODE_TAG);
+ long objectOffset = baseLayerConstant.getObjectOffset();
+ int identityHashCode = baseLayerConstant.getIdentityHashCode();
JavaConstant parentReachableHostedObject;
if (parentReachableHostedObjectCandidate == null) {
- Integer parentConstantId = get(baseLayerConstant, PARENT_CONSTANT_ID_TAG);
- if (parentConstantId != null) {
+ int parentConstantId = baseLayerConstant.getParentConstantId();
+ if (parentConstantId != 0) {
ImageHeapConstant parentConstant = getOrCreateConstant(parentConstantId);
- int index = get(baseLayerConstant, PARENT_CONSTANT_INDEX_TAG);
+ int index = baseLayerConstant.getParentIndex();
parentReachableHostedObject = getReachableHostedValue(parentConstant, index);
} else {
parentReachableHostedObject = null;
@@ -1106,46 +865,49 @@ protected ImageHeapConstant getOrCreateConstant(EconomicMap cons
*/
injectIdentityHashCode(hostedValuesProvider.asObject(Object.class, parentReachableHostedObject), identityHashCode);
}
- String constantType = get(baseLayerConstant, CONSTANT_TYPE_TAG);
- switch (constantType) {
- case INSTANCE_TAG -> {
- List> instanceData = get(baseLayerConstant, DATA_TAG);
- JavaConstant foundHostedObject = lookupHostedObject(baseLayerConstant, type);
- if (foundHostedObject != null && parentReachableHostedObject != null) {
- Object foundObject = hostedValuesProvider.asObject(Object.class, foundHostedObject);
- Object reachableObject = hostedValuesProvider.asObject(Object.class, parentReachableHostedObject);
- AnalysisError.guarantee(foundObject == reachableObject, "Found discrepancy between recipe-found hosted value %s and parent-reachable hosted value %s.", foundObject,
- reachableObject);
- }
+ switch (baseLayerConstant.which()) {
+ case OBJECT -> {
+ switch (baseLayerConstant.getObject().which()) {
+ case INSTANCE -> {
+ StructList.Reader instanceData = baseLayerConstant.getObject().getData();
+ JavaConstant foundHostedObject = lookupHostedObject(baseLayerConstant, type);
+ if (foundHostedObject != null && parentReachableHostedObject != null) {
+ Object foundObject = hostedValuesProvider.asObject(Object.class, foundHostedObject);
+ Object reachableObject = hostedValuesProvider.asObject(Object.class, parentReachableHostedObject);
+ guarantee(foundObject == reachableObject, "Found discrepancy between recipe-found hosted value %s and parent-reachable hosted value %s.", foundObject,
+ reachableObject);
+ }
- addBaseLayerObject(id, objectOffset, () -> {
- ImageHeapInstance imageHeapInstance = new ImageHeapInstance(type, foundHostedObject == null ? parentReachableHostedObject : foundHostedObject, identityHashCode, id);
- if (instanceData != null) {
- Object[] fieldValues = getReferencedValues(constantsMap, imageHeapInstance, instanceData, imageLayerSnapshotUtil.getRelinkedFields(type, metaAccess));
- imageHeapInstance.setFieldValues(fieldValues);
+ addBaseLayerObject(id, objectOffset, () -> {
+ ImageHeapInstance imageHeapInstance = new ImageHeapInstance(type, foundHostedObject == null ? parentReachableHostedObject : foundHostedObject, identityHashCode, id);
+ if (instanceData != null) {
+ Object[] fieldValues = getReferencedValues(imageHeapInstance, instanceData, imageLayerSnapshotUtil.getRelinkedFields(type, metaAccess));
+ imageHeapInstance.setFieldValues(fieldValues);
+ }
+ return imageHeapInstance;
+ });
}
- return imageHeapInstance;
- });
- }
- case ARRAY_TAG -> {
- List> arrayData = get(baseLayerConstant, DATA_TAG);
- addBaseLayerObject(id, objectOffset, () -> {
- ImageHeapObjectArray imageHeapObjectArray = new ImageHeapObjectArray(type, null, arrayData.size(), identityHashCode, id);
- Object[] elementsValues = getReferencedValues(constantsMap, imageHeapObjectArray, arrayData, Set.of());
- imageHeapObjectArray.setElementValues(elementsValues);
- return imageHeapObjectArray;
- });
+ case OBJECT_ARRAY -> {
+ StructList.Reader arrayData = baseLayerConstant.getObject().getData();
+ addBaseLayerObject(id, objectOffset, () -> {
+ ImageHeapObjectArray imageHeapObjectArray = new ImageHeapObjectArray(type, null, arrayData.size(), identityHashCode, id);
+ Object[] elementsValues = getReferencedValues(imageHeapObjectArray, arrayData, Set.of());
+ imageHeapObjectArray.setElementValues(elementsValues);
+ return imageHeapObjectArray;
+ });
+ }
+ default -> throw GraalError.shouldNotReachHere("Unknown object type: " + baseLayerConstant.getObject().which());
+ }
}
- case PRIMITIVE_ARRAY_TAG -> {
- List primitiveData = get(baseLayerConstant, DATA_TAG);
- Object array = getArray(type.getComponentType().getJavaKind(), primitiveData);
- addBaseLayerObject(id, objectOffset, () -> new ImageHeapPrimitiveArray(type, null, array, primitiveData.size(), identityHashCode, id));
+ case PRIMITIVE_DATA -> {
+ Object array = getArray(baseLayerConstant.getPrimitiveData());
+ addBaseLayerObject(id, objectOffset, () -> new ImageHeapPrimitiveArray(type, null, array, Array.getLength(array), identityHashCode, id));
}
- case RELOCATED_CONSTANT_TAG -> {
- String key = get(baseLayerConstant, DATA_TAG);
+ case RELOCATABLE -> {
+ String key = baseLayerConstant.getRelocatable().getKey().toString();
addBaseLayerObject(id, objectOffset, () -> ImageHeapRelocatableConstant.create(type, key, id));
}
- default -> throw GraalError.shouldNotReachHere("Unknown constant type: " + constantType);
+ default -> throw GraalError.shouldNotReachHere("Unknown constant type: " + baseLayerConstant.which());
}
return constants.get(id);
@@ -1154,9 +916,8 @@ protected ImageHeapConstant getOrCreateConstant(EconomicMap cons
/**
* Look up an object in current hosted VM based on the recipe serialized from the base layer.
*/
- protected JavaConstant lookupHostedObject(EconomicMap baseLayerConstant, AnalysisType analysisType) {
- boolean simulated = get(baseLayerConstant, SIMULATED_TAG);
- if (!simulated) {
+ protected JavaConstant lookupHostedObject(PersistedConstant.Reader baseLayerConstant, AnalysisType analysisType) {
+ if (!baseLayerConstant.getIsSimulated()) {
Class clazz = analysisType.getJavaClass();
return lookupHostedObject(baseLayerConstant, clazz);
}
@@ -1164,15 +925,23 @@ protected JavaConstant lookupHostedObject(EconomicMap baseLayerC
}
@SuppressWarnings("unchecked")
- protected JavaConstant lookupHostedObject(EconomicMap baseLayerConstant, Class clazz) {
+ protected JavaConstant lookupHostedObject(PersistedConstant.Reader baseLayerConstant, Class clazz) {
+ if (!baseLayerConstant.isObject() || baseLayerConstant.getObject().getRelinking().isNotRelinked()) {
+ return null;
+ }
+ PersistedConstant.Object.Relinking.Reader relinking = baseLayerConstant.getObject().getRelinking();
if (clazz.equals(String.class)) {
- String value = get(baseLayerConstant, VALUE_TAG);
- if (value != null) {
+ assert relinking.isStringConstant();
+ StringConstant.Reader stringConstant = relinking.getStringConstant();
+ if (stringConstant.hasValue()) {
+ String value = stringConstant.getValue().toString();
Object object = value.intern();
return hostedValuesProvider.forObject(object);
}
} else if (Enum.class.isAssignableFrom(clazz)) {
- Enum enumValue = getEnumValue(baseLayerConstant);
+ assert relinking.isEnumConstant();
+ EnumConstant.Reader enumConstant = relinking.getEnumConstant();
+ Enum enumValue = getEnumValue(enumConstant.getEnumClass(), enumConstant.getEnumName());
return hostedValuesProvider.forObject(enumValue);
}
return null;
@@ -1183,72 +952,52 @@ protected void injectIdentityHashCode(Object object, Integer identityHashCode) {
/* The hash code can only be injected in the SVM context. */
}
- @SuppressWarnings("unchecked")
- private static Object getArray(JavaKind kind, Object listObject) {
- return switch (kind) {
- case Boolean -> getBooleans((List) listObject);
- case Byte -> getBytes((List) listObject);
- case Short -> getShorts((List) listObject);
- case Char -> ((List) listObject).stream().mapToInt(i -> i).mapToObj(i -> Character.toString((char) i)).collect(Collectors.joining()).toCharArray();
- case Int -> ((List) listObject).stream().mapToInt(i -> i).toArray();
- case Long -> ((List) listObject).stream().mapToLong(Long::parseLong).toArray();
- case Float -> getFloats((List) listObject);
- case Double -> ((List) listObject).stream().mapToDouble(Double::parseDouble).toArray();
- default -> throw new IllegalArgumentException("Unsupported kind: " + kind);
+ private static Object getArray(PersistedConstant.PrimitiveData.Reader reader) {
+ return switch (reader.which()) {
+ case Z -> getBooleans(reader.getZ());
+ case B -> toArray(reader.getB(), r -> IntStream.range(0, r.size()).collect(() -> new byte[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case S -> toArray(reader.getS(), r -> IntStream.range(0, r.size()).collect(() -> new short[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case C -> toArray(reader.getC(), r -> IntStream.range(0, r.size()).collect(() -> new char[r.size()], (a, i) -> a[i] = (char) r.get(i), combineUnsupported()));
+ case I -> toArray(reader.getI(), r -> IntStream.range(0, r.size()).collect(() -> new int[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case F -> toArray(reader.getF(), r -> IntStream.range(0, r.size()).collect(() -> new float[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case J -> toArray(reader.getJ(), r -> IntStream.range(0, r.size()).collect(() -> new long[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case D -> toArray(reader.getD(), r -> IntStream.range(0, r.size()).collect(() -> new double[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported()));
+ case _NOT_IN_SCHEMA -> throw new IllegalArgumentException("Unsupported kind: " + reader.which());
};
}
- private static float[] getFloats(List listObject) {
- float[] primitiveFloats = new float[listObject.size()];
- for (int i = 0; i < listObject.size(); ++i) {
- primitiveFloats[i] = Float.parseFloat(listObject.get(i));
- }
- return primitiveFloats;
- }
-
- private static byte[] getBytes(List listObject) {
- byte[] primitiveBytes = new byte[listObject.size()];
- for (int i = 0; i < listObject.size(); ++i) {
- primitiveBytes[i] = (byte) (int) listObject.get(i);
- }
- return primitiveBytes;
+ protected static boolean[] getBooleans(PrimitiveList.Boolean.Reader r) {
+ return IntStream.range(0, r.size()).collect(() -> new boolean[r.size()], (a, i) -> a[i] = r.get(i), combineUnsupported());
}
- private static short[] getShorts(List listObject) {
- short[] primitiveShorts = new short[listObject.size()];
- for (int i = 0; i < listObject.size(); ++i) {
- primitiveShorts[i] = (short) (int) listObject.get(i);
- }
- return primitiveShorts;
+ /** Enables concise one-liners without explicit types in {@link #getArray}. */
+ private static A toArray(T reader, Function fun) {
+ return fun.apply(reader);
}
- private static boolean[] getBooleans(List listObject) {
- boolean[] primitiveBooleans = new boolean[listObject.size()];
- for (int i = 0; i < listObject.size(); ++i) {
- primitiveBooleans[i] = listObject.get(i);
- }
- return primitiveBooleans;
+ private static BiConsumer combineUnsupported() {
+ return (u, v) -> {
+ throw new UnsupportedOperationException("Combining partial results not supported, streams must be sequential");
+ };
}
- private Object[] getReferencedValues(EconomicMap constantsMap, ImageHeapConstant parentConstant, List> data, Set positionsToRelink) {
+ private Object[] getReferencedValues(ImageHeapConstant parentConstant, StructList.Reader data, Set positionsToRelink) {
Object[] values = new Object[data.size()];
for (int position = 0; position < data.size(); ++position) {
- List constantData = data.get(position);
- String constantKind = (String) constantData.get(0);
- Object constantValue = constantData.get(1);
- if (delegateProcessing(constantKind, constantValue, constantData, values, position)) {
+ ConstantReference.Reader constantData = data.get(position);
+ if (delegateProcessing(constantData, values, position)) {
continue;
}
- if (constantKind.equals(OBJECT_TAG)) {
- int constantId = (int) constantValue;
- if (constantId >= 0) {
+ values[position] = switch (constantData.which()) {
+ case OBJECT_CONSTANT -> {
+ int constantId = constantData.getObjectConstant().getConstantId();
boolean relink = positionsToRelink.contains(position);
int finalPosition = position;
- values[position] = new AnalysisFuture<>(() -> {
+ yield new AnalysisFuture<>(() -> {
ensureHubInitialized(parentConstant);
JavaConstant hostedConstant = relink ? getReachableHostedValue(parentConstant, finalPosition) : null;
- ImageHeapConstant baseLayerConstant = getOrCreateConstant(constantsMap, constantId, hostedConstant);
+ ImageHeapConstant baseLayerConstant = getOrCreateConstant(constantId, hostedConstant);
values[finalPosition] = baseLayerConstant;
ensureHubInitialized(baseLayerConstant);
@@ -1259,22 +1008,22 @@ private Object[] getReferencedValues(EconomicMap constantsMap, I
return baseLayerConstant;
});
- } else if (constantId == NULL_POINTER_CONSTANT) {
- values[position] = JavaConstant.NULL_POINTER;
- } else {
+ }
+ case NULL_POINTER -> JavaConstant.NULL_POINTER;
+ case NOT_MATERIALIZED ->
/*
* This constant is a field value or an object value that was not materialized
* in the base image.
*/
- guarantee(constantId == NOT_MATERIALIZED_CONSTANT);
- values[position] = new AnalysisFuture<>(() -> {
+ new AnalysisFuture<>(() -> {
throw AnalysisError.shouldNotReachHere("This constant was not materialized in the base image.");
});
+ case PRIMITIVE_VALUE -> {
+ ConstantReference.PrimitiveValue.Reader pv = constantData.getPrimitiveValue();
+ yield JavaConstant.forPrimitive((char) pv.getTypeChar(), pv.getRawValue());
}
- } else {
- JavaKind kind = JavaKind.fromTypeString(constantKind);
- values[position] = getPrimitiveValue(kind, constantValue);
- }
+ default -> throw GraalError.shouldNotReachHere("Unexpected constant reference: " + constantData.which());
+ };
}
return values;
}
@@ -1283,7 +1032,7 @@ private Object[] getReferencedValues(EconomicMap constantsMap, I
* Hook for subclasses to do their own processing.
*/
@SuppressWarnings("unused")
- protected boolean delegateProcessing(String constantType, Object constantValue, List constantData, Object[] values, int i) {
+ protected boolean delegateProcessing(ConstantReference.Reader constantRef, Object[] values, int i) {
return false;
}
@@ -1350,29 +1099,7 @@ public void rescanHub(AnalysisType type, Object hubObject) {
/* DynamicHub only exists in SVM, so the method does not need to do anything here. */
}
- private static PrimitiveConstant getPrimitiveValue(JavaKind kind, Object value) {
- return switch (kind) {
- case Boolean -> JavaConstant.forBoolean((int) value != 0);
- case Byte -> JavaConstant.forByte((byte) (int) value);
- case Short -> JavaConstant.forShort((short) (int) value);
- case Char -> JavaConstant.forChar((char) Integer.parseInt((String) value));
- case Int -> JavaConstant.forInt((int) value);
- case Long -> JavaConstant.forLong(Long.parseLong((String) value));
- case Float -> JavaConstant.forFloat(Float.parseFloat((String) value));
- case Double -> JavaConstant.forDouble(getDouble(value));
- default -> throw AnalysisError.shouldNotReachHere("Unexpected kind: " + kind);
- };
- }
-
- private static double getDouble(Object value) {
- if (value instanceof Integer integer) {
- guarantee(integer == 0);
- return 0;
- }
- return Double.longBitsToDouble((long) value);
- }
-
- private void addBaseLayerObject(int id, String objectOffset, Supplier imageHeapConstantSupplier) {
+ private void addBaseLayerObject(int id, long objectOffset, Supplier imageHeapConstantSupplier) {
constants.computeIfAbsent(id, key -> {
ImageHeapConstant heapObj = imageHeapConstantSupplier.get();
heapObj.markInBaseLayer();
@@ -1384,47 +1111,24 @@ private void addBaseLayerObject(int id, String objectOffset, Supplier getElementData(String registry, String elementIdentifier) {
- EconomicMap innerMap = get(jsonMap, registry);
- if (innerMap == null) {
- return null;
- }
- return get(innerMap, elementIdentifier);
- }
-
@SuppressWarnings("unchecked")
- protected Enum getEnumValue(EconomicMap enumData) {
- String className = get(enumData, ENUM_CLASS_TAG);
- Class enumClass = lookupClass(false, className);
- String name = get(enumData, ENUM_NAME_TAG);
+ protected final Enum getEnumValue(Text.Reader className, Text.Reader name) {
+ Class enumClass = lookupClass(false, className.toString());
/* asSubclass produces an "unchecked" warning */
- return Enum.valueOf(enumClass.asSubclass(Enum.class), name);
+ return Enum.valueOf(enumClass.asSubclass(Enum.class), name.toString());
}
public Class lookupClass(boolean optional, String className) {
return ReflectionUtil.lookupClass(optional, className);
}
- public static T get(EconomicMap innerMap, String elementIdentifier) {
- return cast(innerMap.get(elementIdentifier));
- }
-
- private static T getValue(MapCursor mapCursor) {
- return cast(mapCursor.getValue());
- }
-
- @SuppressWarnings("unchecked")
- protected static T cast(Object object) {
- return (T) object;
- }
-
public boolean hasValueForConstant(JavaConstant javaConstant) {
Object object = hostedValuesProvider.asObject(Object.class, javaConstant);
return hasValueForObject(object);
@@ -1457,7 +1161,7 @@ protected ImageHeapConstant getValueForObject(Object object) {
}
public ImageHeapConstant getOrCreateConstant(int id) {
- return getOrCreateConstant(get(jsonMap, CONSTANTS_TAG), id, null);
+ return getOrCreateConstant(id, null);
}
public AnalysisMetaAccess getMetaAccess() {
@@ -1486,20 +1190,15 @@ public int getFieldLocation(AnalysisField field) {
}
public ImageHeapConstant getBaseLayerStaticPrimitiveFields() {
- return getTaggedImageHeapConstant(STATIC_PRIMITIVE_FIELDS_TAG);
+ return getOrCreateConstant(snapshot.getStaticPrimitiveFieldsConstantId());
}
public ImageHeapConstant getBaseLayerStaticObjectFields() {
- return getTaggedImageHeapConstant(STATIC_OBJECT_FIELDS_TAG);
- }
-
- private ImageHeapConstant getTaggedImageHeapConstant(String tag) {
- int id = get(jsonMap, tag);
- return getOrCreateConstant(id);
+ return getOrCreateConstant(snapshot.getStaticObjectFieldsConstantId());
}
public long getImageHeapSize() {
- return imageHeapSize;
+ return snapshot.getImageHeapSize();
}
public boolean hasDynamicHubIdentityHashCode(int tid) {
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoaderHelper.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoaderHelper.java
index 01bd77248601..67f577b4f985 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoaderHelper.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerLoaderHelper.java
@@ -24,7 +24,8 @@
*/
package com.oracle.graal.pointsto.heap;
-import org.graalvm.collections.EconomicMap;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisMethod;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisType;
public class ImageLayerLoaderHelper {
protected ImageLayerLoader imageLayerLoader;
@@ -34,12 +35,12 @@ public ImageLayerLoaderHelper(ImageLayerLoader imageLayerLoader) {
}
@SuppressWarnings("unused")
- protected boolean loadType(EconomicMap typeData, int tid) {
+ protected boolean loadType(PersistedAnalysisType.Reader typeData, int tid) {
return false;
}
@SuppressWarnings("unused")
- protected boolean loadMethod(EconomicMap methodData, int mid) {
+ protected boolean loadMethod(PersistedAnalysisMethod.Reader methodData, int mid) {
return false;
}
}
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerSnapshotUtil.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerSnapshotUtil.java
index 70e6e39fbd37..770ff202c770 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerSnapshotUtil.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerSnapshotUtil.java
@@ -40,7 +40,6 @@
import com.oracle.graal.pointsto.meta.PointsToAnalysisMethod;
import com.oracle.graal.pointsto.meta.PointsToAnalysisType;
import com.oracle.graal.pointsto.util.AnalysisError;
-import com.oracle.graal.pointsto.util.AnalysisFuture;
import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
import jdk.graal.compiler.nodes.EncodedGraph;
@@ -51,7 +50,7 @@
public class ImageLayerSnapshotUtil {
public static final String FILE_NAME_PREFIX = "layer-snapshot-";
- public static final String FILE_EXTENSION = ".json";
+ public static final String FILE_EXTENSION = ".lsb";
public static final String GRAPHS_FILE_NAME_PREFIX = "layer-snapshot-graphs-";
public static final String GRAPHS_FILE_EXTENSION = ".big";
@@ -62,125 +61,6 @@ public class ImageLayerSnapshotUtil {
public static final int UNDEFINED_CONSTANT_ID = -1;
public static final int UNDEFINED_FIELD_INDEX = -1;
- public static final int NULL_POINTER_CONSTANT = -1;
- public static final int NOT_MATERIALIZED_CONSTANT = -2;
- public static final String OBJECT_TAG = "A";
- public static final String METHOD_POINTER_TAG = "M";
- public static final String C_ENTRY_POINT_LITERAL_CODE_POINTER = "CONSTANT";
- public static final String TYPES_TAG = "types";
- public static final String METHODS_TAG = "methods";
- public static final String FIELDS_TAG = "fields";
- public static final String IS_INTERNAL_TAG = "is internal";
- public static final String IS_STATIC_TAG = "is static";
- public static final String FIELD_TYPE_TAG = "field type";
- public static final String CLASS_JAVA_NAME_TAG = "class java name";
- public static final String CAN_BE_STATICALLY_BOUND_TAG = "can be statically bound";
- public static final String IS_CONSTRUCTOR_TAG = "is constructor";
- public static final String IS_SYNTHETIC_TAG = "is synthetic";
- public static final String CODE_TAG = "code";
- public static final String CODE_SIZE_TAG = "code size";
- public static final String METHOD_HANDLE_INTRINSIC_TAG = "method handle intrinsic";
- public static final String IS_VIRTUAL_ROOT_METHOD = "is virtual root method";
- public static final String IS_DIRECT_ROOT_METHOD = "is direct root method";
- public static final String IS_INVOKED = "is invoked";
- public static final String IS_IMPLEMENTATION_INVOKED = "is implementation invoked";
- public static final String IS_INTRINSIC_METHOD = "is intrinsic method";
- public static final String ANNOTATIONS_TAG = "annotations";
- public static final String ANNOTATION_VALUES_TAG = "annotation values";
- public static final String IS_INSTANTIATED = "is instantiated";
- public static final String IS_UNSAFE_ALLOCATED = "is unsafe allocated";
- public static final String IS_REACHABLE = "is reachable";
- public static final String CLASS_NAME_TAG = "class name";
- public static final String MODIFIERS_TAG = "modifiers";
- public static final String POSITION_TAG = "position";
- public static final String IS_INTERFACE_TAG = "is interface";
- public static final String IS_ENUM_TAG = "is enum";
- public static final String IS_INITIALIZED_TAG = "is initialized";
- public static final String IS_LINKED_TAG = "is linked";
- public static final String SOURCE_FILE_NAME_TAG = "source file name";
- public static final String ENCLOSING_TYPE_TAG = "enclosing type";
- public static final String COMPONENT_TYPE_TAG = "component type";
- public static final String SUPER_CLASS_TAG = "super class";
- public static final String INTERFACES_TAG = "interfaces";
- public static final String WRAPPED_TYPE_TAG = "wrapped type";
- public static final String GENERATED_SERIALIZATION_TAG = "generated serialization";
- public static final String LAMBDA_TYPE_TAG = "lambda type";
- public static final String CAPTURING_CLASS_TAG = "capturing class";
- public static final String PROXY_TYPE_TAG = "proxy type";
- public static final String RAW_DECLARING_CLASS_TAG = "raw declaring class";
- public static final String RAW_TARGET_CONSTRUCTOR_CLASS_TAG = "raw target constructor class";
- public static final String INSTANCE_FIELDS_TAG = "instance fields";
- public static final String INSTANCE_FIELDS_WITH_SUPER_TAG = "instance fields with super";
- public static final String CONSTANTS_TAG = "constants";
- public static final String CONSTANTS_TO_RELINK_TAG = "constants to relink";
- public static final String TID_TAG = "tid";
- public static final String NAME_TAG = "name";
- public static final String ARGUMENTS_TAG = "arguments";
- public static final String ARGUMENT_IDS_TAG = "argument ids";
- public static final String RETURN_TYPE_TAG = "return type";
- public static final String IS_VAR_ARGS_TAG = "is varArg";
- public static final String WRAPPED_METHOD_TAG = "wrapped method";
- public static final String METHOD_TYPE_PARAMETERS_TAG = "method type parameters";
- public static final String METHOD_TYPE_RETURN_TAG = "method type return";
- public static final String FACTORY_TAG = "factory";
- public static final String C_ENTRY_POINT_CALL_STUB_METHOD_TAG = "CEntryPointCallStubMethod";
- public static final String REFLECTION_EXPAND_SIGNATURE_METHOD_TAG = "reflection expand signature method";
- public static final String JNI_JAVA_CALL_VARIANT_WRAPPER_METHOD_TAG = "jni java call variant wrapper method";
- public static final String OUTLINED_SB_TAG = "outlinedSB";
- public static final String ORIGINAL_METHOD_ID_TAG = "original method id";
- public static final String NOT_AS_PUBLISHED_TAG = "not as published";
- public static final String TARGET_CONSTRUCTOR_TAG = "target constructor";
- public static final String INSTANTIATED_TYPE_TAG = "instantiated type";
- public static final String WRAPPED_MEMBER_CLASS_TAG = "wrapped member class";
- public static final String WRAPPED_MEMBER_NAME_TAG = "wrapped member name";
- public static final String WRAPPED_MEMBER_ARGUMENTS_TAG = "wrapped member arguments";
- public static final String THROW_ALLOCATED_OBJECT_TAG = "throw allocated object";
- public static final String IDENTITY_HASH_CODE_TAG = "identityHashCode";
- public static final String PARENT_CONSTANT_ID_TAG = "parent constant id";
- public static final String PARENT_CONSTANT_INDEX_TAG = "parent constant index";
- public static final String HUB_IDENTITY_HASH_CODE_TAG = "hub identityHashCode";
- public static final String IS_INITIALIZED_AT_BUILD_TIME_TAG = "is initialized at build time";
- public static final String IS_NO_INITIALIZER_NO_TRACKING_TAG = "in no initializer no tracking";
- public static final String IS_INITIALIZED_NO_TRACKING_TAG = "is initialized no tracking";
- public static final String IS_FAILED_NO_TRACKING_TAG = "is failed no tracking";
- public static final String INFO_IS_INITIALIZED_TAG = "info is initialized";
- public static final String INFO_IS_IN_ERROR_STATE_TAG = "info is in error state";
- public static final String INFO_IS_LINKED_TAG = "info is linked";
- public static final String INFO_HAS_INITIALIZER_TAG = "info has initializer";
- public static final String INFO_IS_BUILD_TIME_INITIALIZED_TAG = "info is build time initialized";
- public static final String INFO_IS_TRACKED_TAG = "info is tracked";
- public static final String INFO_CLASS_INITIALIZER_TAG = "info class initializer";
- public static final String ID_TAG = "id";
- public static final String ANALYSIS_PARSED_GRAPH_TAG = "analysis parsed graph";
- public static final String STRENGTHENED_GRAPH_TAG = "strengthened graph";
- public static final String INTRINSIC_TAG = "intrinsic";
- public static final String CONSTANT_TYPE_TAG = "constant type";
- public static final String DATA_TAG = "data";
- public static final String INSTANCE_TAG = "instance";
- public static final String ARRAY_TAG = "array";
- public static final String PRIMITIVE_ARRAY_TAG = "primitive array";
- public static final String RELOCATED_CONSTANT_TAG = "relocation constant";
- public static final String FIELD_CHECK_TAG = "field check";
- public static final String FIELD_ACCESSED_TAG = "accessed";
- public static final String FIELD_READ_TAG = "read";
- public static final String FIELD_WRITTEN_TAG = "written";
- public static final String FIELD_FOLDED_TAG = "folded";
- public static final String LOCATION_TAG = "location";
- public static final String NEXT_TYPE_ID_TAG = "next type id";
- public static final String NEXT_METHOD_ID_TAG = "next method id";
- public static final String NEXT_FIELD_ID_TAG = "next field id";
- public static final String NEXT_CONSTANT_ID_TAG = "next constant id";
- public static final String IMAGE_HEAP_SIZE_TAG = "image heap size";
- public static final String VALUE_TAG = "value";
- public static final String ENUM_CLASS_TAG = "enum class";
- public static final String ENUM_NAME_TAG = "enum name";
- public static final String CLASS_ID_TAG = "class id";
- public static final String SIMULATED_TAG = "simulated";
- public static final String OBJECT_OFFSET_TAG = "object offset";
- public static final String STATIC_PRIMITIVE_FIELDS_TAG = "static primitive fields";
- public static final String STATIC_OBJECT_FIELDS_TAG = "static object fields";
- public static final String IMAGE_SINGLETON_KEYS = "image singleton keys";
- public static final String IMAGE_SINGLETON_OBJECTS = "image singleton objects";
protected final List externalValueFields;
/** This needs to be initialized after analysis, as some fields are not available before. */
@@ -214,12 +94,12 @@ public static String snapshotGraphsFileName(String imageName) {
return GRAPHS_FILE_NAME_PREFIX + imageName + GRAPHS_FILE_EXTENSION;
}
- public String getTypeIdentifier(AnalysisType type) {
+ public String getTypeDescriptor(AnalysisType type) {
String javaName = type.toJavaName(true);
return addModuleName(javaName, type.getJavaClass().getModule().getName());
}
- public String getMethodIdentifier(AnalysisMethod method) {
+ public String getMethodDescriptor(AnalysisMethod method) {
AnalysisType declaringClass = method.getDeclaringClass();
Executable originalMethod = OriginalMethodProvider.getJavaMethod(method);
String moduleName = declaringClass.getJavaClass().getModule().getName();
@@ -300,7 +180,7 @@ protected ImageHeapConstantBuiltIn(ImageLayerWriter imageLayerWriter, ImageLayer
@Override
public void encode(ObjectCopier.Encoder encoder, ObjectCopierOutputStream stream, Object obj) throws IOException {
ImageHeapConstant imageHeapConstant = (ImageHeapConstant) obj;
- imageLayerWriter.elementsToPersist.add(new AnalysisFuture<>(() -> imageLayerWriter.persistConstant(UNDEFINED_CONSTANT_ID, UNDEFINED_FIELD_INDEX, imageHeapConstant)));
+ imageLayerWriter.ensureConstantPersisted(imageHeapConstant);
stream.writePackedUnsignedInt(imageHeapConstant.getConstantData().id);
}
@@ -324,14 +204,14 @@ protected AnalysisTypeBuiltIn(ImageLayerWriter imageLayerWriter, ImageLayerLoade
@Override
public void encode(ObjectCopier.Encoder encoder, ObjectCopierOutputStream stream, Object obj) throws IOException {
AnalysisType type = (AnalysisType) obj;
- imageLayerWriter.persistType(type);
+ imageLayerWriter.ensureTypePersisted(type);
stream.writePackedUnsignedInt(type.getId());
}
@Override
protected Object decode(ObjectCopier.Decoder decoder, Class concreteType, ObjectCopierInputStream stream) throws IOException {
int id = stream.readPackedUnsignedInt();
- return imageLayerLoader.getAnalysisType(id);
+ return imageLayerLoader.getAnalysisTypeForBaseLayerId(id);
}
}
@@ -351,14 +231,11 @@ protected AnalysisMethodBuiltIn(ImageLayerWriter imageLayerWriter, ImageLayerLoa
public void encode(ObjectCopier.Encoder encoder, ObjectCopierOutputStream stream, Object obj) throws IOException {
AnalysisMethod method = (AnalysisMethod) obj;
AnalysisType declaringClass = method.getDeclaringClass();
- imageLayerWriter.elementsToPersist.add(new AnalysisFuture<>(() -> {
- imageLayerWriter.persistAnalysisParsedGraph(method);
- imageLayerWriter.persistMethod(method);
- }));
+ imageLayerWriter.ensureMethodPersisted(method);
for (AnalysisType parameter : method.toParameterList()) {
- imageLayerWriter.persistType(parameter);
+ imageLayerWriter.ensureTypePersisted(parameter);
}
- imageLayerWriter.persistType(declaringClass);
+ imageLayerWriter.ensureTypePersisted(declaringClass);
stream.writePackedUnsignedInt(method.getId());
}
@@ -368,7 +245,7 @@ protected Object decode(ObjectCopier.Decoder decoder, Class concreteType, Obj
if (id == analysisMethod.getId()) {
return analysisMethod;
}
- return imageLayerLoader.getAnalysisMethod(id);
+ return imageLayerLoader.getAnalysisMethodForBaseLayerId(id);
}
}
@@ -422,14 +299,11 @@ protected Object decode(ObjectCopier.Decoder decoder, Class concreteType, Obj
}
private static int encodeField(AnalysisField field, ImageLayerWriter imageLayerWriter) {
- String declaringClassId = String.valueOf(field.getDeclaringClass().getId());
- if (!imageLayerWriter.fieldsMap.containsKey(declaringClassId) || !imageLayerWriter.fieldsMap.get(declaringClassId).containsKey(field.getName())) {
- imageLayerWriter.persistField(field);
- }
+ imageLayerWriter.ensureFieldPersisted(field);
return field.getId();
}
private static AnalysisField decodeField(ImageLayerLoader imageLayerLoader, int id) {
- return imageLayerLoader.getAnalysisField(id);
+ return imageLayerLoader.getAnalysisFieldForBaseLayerId(id);
}
}
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriter.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriter.java
index 0844e76d51b7..ff5b4725b85a 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriter.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriter.java
@@ -24,109 +24,64 @@
*/
package com.oracle.graal.pointsto.heap;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ANALYSIS_PARSED_GRAPH_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ANNOTATIONS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARGUMENTS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARGUMENT_IDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ARRAY_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CAN_BE_STATICALLY_BOUND_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CLASS_JAVA_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CLASS_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CODE_SIZE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CODE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.COMPONENT_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANTS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANTS_TO_RELINK_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.CONSTANT_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.DATA_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENCLOSING_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENUM_CLASS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ENUM_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_ACCESSED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_FOLDED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_READ_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.FIELD_WRITTEN_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IDENTITY_HASH_CODE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IMAGE_HEAP_SIZE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_FIELDS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_FIELDS_WITH_SUPER_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INSTANCE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INTERFACES_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.INTRINSIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_CONSTRUCTOR_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_DIRECT_ROOT_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_ENUM_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_IMPLEMENTATION_INVOKED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INITIALIZED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INSTANTIATED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTERFACE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTERNAL_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INTRINSIC_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_INVOKED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_LINKED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_REACHABLE;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_STATIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_SYNTHETIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_UNSAFE_ALLOCATED;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_VAR_ARGS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.IS_VIRTUAL_ROOT_METHOD;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.METHODS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.METHOD_HANDLE_INTRINSIC_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.MODIFIERS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_CONSTANT_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_FIELD_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_METHOD_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NEXT_TYPE_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NOT_MATERIALIZED_CONSTANT;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.NULL_POINTER_CONSTANT;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.OBJECT_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PARENT_CONSTANT_ID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PARENT_CONSTANT_INDEX_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.POSITION_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.PRIMITIVE_ARRAY_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.RELOCATED_CONSTANT_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.RETURN_TYPE_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SIMULATED_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SOURCE_FILE_NAME_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.STRENGTHENED_GRAPH_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.SUPER_CLASS_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.TID_TAG;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.TYPES_TAG;
import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.UNDEFINED_CONSTANT_ID;
import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.UNDEFINED_FIELD_INDEX;
-import static com.oracle.graal.pointsto.heap.ImageLayerSnapshotUtil.VALUE_TAG;
import java.io.IOException;
-import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Array;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.IdentityHashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.BiConsumer;
+import java.util.function.IntFunction;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Supplier;
import java.util.stream.IntStream;
-
-import org.graalvm.collections.EconomicMap;
+import java.util.stream.Stream;
+
+import org.capnproto.ListBuilder;
+import org.capnproto.MessageBuilder;
+import org.capnproto.PrimitiveList;
+import org.capnproto.Serialize;
+import org.capnproto.StructBuilder;
+import org.capnproto.StructList;
+import org.capnproto.Text;
+import org.capnproto.TextList;
+import org.capnproto.Void;
import org.graalvm.nativeimage.AnnotationAccess;
import com.oracle.graal.pointsto.BigBang;
import com.oracle.graal.pointsto.flow.AnalysisParsedGraph;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ConstantReference;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisField;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisMethod;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisType;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant.Object.Relinking.EnumConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedConstant.Object.Relinking.StringConstant;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.SharedLayerSnapshot;
import com.oracle.graal.pointsto.infrastructure.OriginalFieldProvider;
import com.oracle.graal.pointsto.meta.AnalysisField;
import com.oracle.graal.pointsto.meta.AnalysisMethod;
@@ -136,17 +91,16 @@
import com.oracle.graal.pointsto.util.AnalysisFuture;
import com.oracle.svm.util.FileDumpingUtil;
+import jdk.graal.compiler.core.common.NumUtil;
import jdk.graal.compiler.debug.GraalError;
import jdk.graal.compiler.java.LambdaUtils;
import jdk.graal.compiler.nodes.EncodedGraph;
import jdk.graal.compiler.nodes.spi.IdentityHashCodeProvider;
import jdk.graal.compiler.util.ObjectCopier;
-import jdk.graal.compiler.util.json.JsonWriter;
import jdk.vm.ci.meta.JavaConstant;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.MethodHandleAccessProvider.IntrinsicMethod;
import jdk.vm.ci.meta.PrimitiveConstant;
-import jdk.vm.ci.meta.ResolvedJavaField;
public class ImageLayerWriter {
protected ImageLayerSnapshotUtil imageLayerSnapshotUtil;
@@ -155,24 +109,72 @@ public class ImageLayerWriter {
protected AnalysisUniverse aUniverse;
private IdentityHashMap internedStringsIdentityMap;
- protected final EconomicMap jsonMap;
- protected final List constantsToRelink;
- private final Set persistedTypeIds;
- private final Set persistedMethodIds;
- protected final Map> typesMap;
- protected final Map> methodsMap;
- protected final Map> fieldsMap;
- private final Map> constantsMap;
+ private final MessageBuilder snapshotFileBuilder = new MessageBuilder();
+ protected final SharedLayerSnapshot.Builder snapshotBuilder = this.snapshotFileBuilder.initRoot(SharedLayerSnapshot.factory);
+ private Map constantsMap;
+ private final Map methodsMap = new ConcurrentHashMap<>();
private FileInfo fileInfo;
private GraphsOutput graphsOutput;
private final boolean useSharedLayerGraphs;
private final boolean useSharedLayerStrengthenedGraphs;
- protected final Set> elementsToPersist = ConcurrentHashMap.newKeySet();
+ /*
+ * Types, members and constants to persist even when they are not considered reachable by the
+ * analysis, or referenced from the image heap. Typically, these elements would be reachable
+ * from a persisted graph.
+ */
+ private boolean sealed = false;
+ private final Set typesToPersist = ConcurrentHashMap.newKeySet();
+ private final Set methodsToPersist = ConcurrentHashMap.newKeySet();
+ private final Set fieldsToPersist = ConcurrentHashMap.newKeySet();
+ private final Set constantsToPersist = ConcurrentHashMap.newKeySet();
+
+ public void ensureTypePersisted(AnalysisType type) {
+ assert !sealed;
+ if (typesToPersist.add(type)) {
+ afterTypeAdded(type);
+ }
+ }
+
+ public void ensureMethodPersisted(AnalysisMethod method) {
+ assert !sealed;
+ if (methodsToPersist.add(method)) {
+ afterMethodAdded(method);
+ }
+ }
+
+ public void ensureFieldPersisted(AnalysisField field) {
+ assert !sealed;
+ fieldsToPersist.add(field);
+ }
+
+ public void ensureConstantPersisted(ImageHeapConstant constant) {
+ assert !sealed;
+ constantsToPersist.add(constant);
+ }
+
+ protected record ConstantParent(int constantId, int index) {
+ static ConstantParent NONE = new ConstantParent(UNDEFINED_CONSTANT_ID, UNDEFINED_FIELD_INDEX);
+ }
private record FileInfo(Path layerFilePath, String fileName, String suffix) {
}
+ protected record MethodGraphsInfo(String analysisGraphLocation, boolean analysisGraphIsIntrinsic, String strengthenedGraphLocation) {
+
+ static final MethodGraphsInfo NO_GRAPHS = new MethodGraphsInfo(null, false, null);
+
+ MethodGraphsInfo withAnalysisGraph(String location, boolean isIntrinsic) {
+ assert analysisGraphLocation == null && !analysisGraphIsIntrinsic;
+ return new MethodGraphsInfo(location, isIntrinsic, strengthenedGraphLocation);
+ }
+
+ MethodGraphsInfo withStrengthenedGraph(String location) {
+ assert strengthenedGraphLocation == null;
+ return new MethodGraphsInfo(analysisGraphLocation, analysisGraphIsIntrinsic, location);
+ }
+ }
+
private static class GraphsOutput {
private final Path path;
private final Path tempPath;
@@ -217,14 +219,6 @@ public ImageLayerWriter() {
public ImageLayerWriter(boolean useSharedLayerGraphs) {
this.useSharedLayerGraphs = useSharedLayerGraphs;
this.useSharedLayerStrengthenedGraphs = false;
- this.jsonMap = EconomicMap.create();
- this.constantsToRelink = new ArrayList<>();
- this.persistedTypeIds = ConcurrentHashMap.newKeySet();
- this.persistedMethodIds = ConcurrentHashMap.newKeySet();
- this.typesMap = new ConcurrentHashMap<>();
- this.methodsMap = new ConcurrentHashMap<>();
- this.fieldsMap = new ConcurrentHashMap<>();
- this.constantsMap = new ConcurrentHashMap<>();
}
public void setImageLayerSnapshotUtil(ImageLayerSnapshotUtil imageLayerSnapshotUtil) {
@@ -260,8 +254,8 @@ public void dumpFiles() {
graphsOutput.finish();
FileDumpingUtil.dumpFile(fileInfo.layerFilePath, fileInfo.fileName, fileInfo.suffix, outputStream -> {
- try (JsonWriter jw = new JsonWriter(new PrintWriter(outputStream))) {
- jw.print(jsonMap);
+ try {
+ Serialize.write(Channels.newChannel(outputStream), snapshotFileBuilder);
} catch (IOException e) {
throw new RuntimeException(e);
}
@@ -272,54 +266,71 @@ public void initializeExternalValues() {
imageLayerSnapshotUtil.initializeExternalValues();
}
- public void persistImageHeapSize(long imageHeapSize) {
- jsonMap.put(IMAGE_HEAP_SIZE_TAG, String.valueOf(imageHeapSize));
+ public void setImageHeapSize(long imageHeapSize) {
+ snapshotBuilder.setImageHeapSize(imageHeapSize);
}
public void persistAnalysisInfo() {
persistHook();
- jsonMap.put(NEXT_TYPE_ID_TAG, aUniverse.getNextTypeId());
- jsonMap.put(NEXT_METHOD_ID_TAG, aUniverse.getNextMethodId());
- jsonMap.put(NEXT_FIELD_ID_TAG, aUniverse.getNextFieldId());
- jsonMap.put(NEXT_CONSTANT_ID_TAG, ImageHeapConstant.getCurrentId());
-
- for (AnalysisType type : aUniverse.getTypes().stream().filter(AnalysisType::isTrackedAcrossLayers).toList()) {
- checkTypeStability(type);
- persistType(type);
+ // Late constant scan so all of them are known with values available (readers installed)
+ List constantsToScan = new ArrayList<>(constantsToPersist);
+ imageHeap.getReachableObjects().values().forEach(constantsToScan::addAll);
+ constantsMap = HashMap.newHashMap(constantsToScan.size());
+ constantsToScan.forEach(c -> constantsMap.put(c, ConstantParent.NONE));
+ while (!constantsToScan.isEmpty()) {
+ List discoveredConstants = new ArrayList<>();
+ constantsToScan.forEach(con -> scanConstantReferencedObjects(con, discoveredConstants));
+ constantsToScan = discoveredConstants;
}
- jsonMap.put(TYPES_TAG, typesMap);
- for (AnalysisMethod method : aUniverse.getMethods().stream().filter(AnalysisMethod::isTrackedAcrossLayers).toList()) {
- persistMethod(method);
- }
- jsonMap.put(METHODS_TAG, methodsMap);
+ snapshotBuilder.setNextTypeId(aUniverse.getNextTypeId());
+ snapshotBuilder.setNextMethodId(aUniverse.getNextMethodId());
+ snapshotBuilder.setNextFieldId(aUniverse.getNextFieldId());
+ snapshotBuilder.setNextConstantId(ImageHeapConstant.getCurrentId());
- for (AnalysisField field : aUniverse.getFields().stream().filter(AnalysisField::isTrackedAcrossLayers).toList()) {
- persistField(field);
- }
- jsonMap.put(FIELDS_TAG, fieldsMap);
+ initSortedList(snapshotBuilder::initTypes, typesToPersist, Comparator.comparingInt(AnalysisType::getId), this::persistType);
+ initSortedList(snapshotBuilder::initMethods, methodsToPersist, Comparator.comparingInt(AnalysisMethod::getId), this::persistMethod);
+ initSortedList(snapshotBuilder::initFields, fieldsToPersist, Comparator.comparingInt(AnalysisField::getId), this::persistField);
- for (Map.Entry> entry : imageHeap.getReachableObjects().entrySet()) {
- for (ImageHeapConstant imageHeapConstant : entry.getValue()) {
- persistConstant(UNDEFINED_CONSTANT_ID, UNDEFINED_FIELD_INDEX, imageHeapConstant);
- }
- }
- for (AnalysisFuture task : elementsToPersist) {
- task.ensureDone();
+ Set constantsToRelink = new HashSet<>();
+ initSortedList(snapshotBuilder::initConstants, constantsMap.entrySet(),
+ (a, b) -> Integer.compare(getConstantId(a.getKey()), getConstantId(b.getKey())),
+ (entry, bsupplier) -> persistConstant(entry.getKey(), entry.getValue(), bsupplier.get(), constantsToRelink));
+ initInts(snapshotBuilder::initConstantsToRelink, constantsToRelink.stream().mapToInt(i -> i).sorted());
+ }
+
+ protected static void initSortedList(IntFunction> init, Collection objects, Comparator comparator, BiConsumer> action) {
+ @SuppressWarnings("unchecked")
+ T[] array = (T[]) objects.toArray();
+ Arrays.sort(array, comparator);
+
+ StructList.Builder builder = init.apply(objects.size());
+ Iterator iterator = builder.iterator();
+ for (T t : array) {
+ action.accept(t, iterator::next);
}
- jsonMap.put(CONSTANTS_TAG, constantsMap);
- jsonMap.put(CONSTANTS_TO_RELINK_TAG, constantsToRelink);
+ AnalysisError.guarantee(!iterator.hasNext(), "all created struct builders must have been used");
}
- private void persistAnnotations(AnnotatedElement annotatedElement, EconomicMap typeMap) {
+ private void persistAnnotations(AnnotatedElement annotatedElement, IntFunction> builder) {
Class[] annotationTypes = AnnotationAccess.getAnnotationTypes(annotatedElement);
- persistAnnotations(annotatedElement, typeMap, annotationTypes);
+ persistAnnotations(annotatedElement, annotationTypes, builder);
+ }
+
+ @SuppressWarnings("unused")
+ protected void persistAnnotations(AnnotatedElement annotatedElement, Class[] annotationTypes,
+ IntFunction> builder) {
+ var b = builder.apply(annotationTypes.length);
+ for (int i = 0; i < annotationTypes.length; i++) {
+ b.get(i).setTypeName(annotationTypes[i].getName());
+ persistAnnotationValues(annotatedElement, annotationTypes[i], b.get(i)::initValues);
+ }
}
@SuppressWarnings("unused")
- protected void persistAnnotations(AnnotatedElement annotatedElement, EconomicMap typeMap, Class[] annotationTypes) {
- typeMap.put(ANNOTATIONS_TAG, Arrays.stream(annotationTypes).map(Class::getName).toList());
+ protected void persistAnnotationValues(AnnotatedElement annotatedElement, Class annotationType,
+ IntFunction> builder) {
}
/**
@@ -332,61 +343,33 @@ protected void persistHook() {
}
public boolean isTypePersisted(AnalysisType type) {
- return persistedTypeIds.contains(type.getId());
+ return typesToPersist.contains(type);
}
- protected void persistType(AnalysisType type) {
- if (!persistedTypeIds.add(type.getId())) {
- return;
- }
- String typeIdentifier = imageLayerSnapshotUtil.getTypeIdentifier(type);
- AnalysisType superclass = type.getSuperclass();
- if (superclass != null) {
- /*
- * Some persisted types are not reachable. In this case, the super class has to be
- * persisted manually as well.
- */
- persistType(superclass);
- }
-
- for (AnalysisType interfaceType : type.getInterfaces()) {
- /*
- * Some persisted types are not reachable. In this case, the interfaces have to be
- * persisted manually as well.
- */
- persistType(interfaceType);
- }
-
- EconomicMap typeMap = EconomicMap.create();
-
- persistType(type, typeMap);
-
- if (typesMap.containsKey(typeIdentifier)) {
- throw GraalError.shouldNotReachHere("The type identifier should be unique, but " + typeIdentifier + " got added twice.");
- }
- typesMap.put(typeIdentifier, typeMap);
+ private void persistType(AnalysisType type, Supplier builderSupplier) {
+ String typeDescriptor = imageLayerSnapshotUtil.getTypeDescriptor(type);
+ persistType(type, typeDescriptor, builderSupplier.get());
}
- protected void persistType(AnalysisType type, EconomicMap typeMap) {
- typeMap.put(ID_TAG, type.getId());
+ protected void persistType(AnalysisType type, String typeDescriptor, PersistedAnalysisType.Builder builder) {
+ builder.setId(type.getId());
+ builder.setDescriptor(typeDescriptor);
- List fields = new ArrayList<>();
- for (ResolvedJavaField field : type.getInstanceFields(true)) {
- fields.add(((AnalysisField) field).getId());
+ initInts(builder::initFields, Arrays.stream(type.getInstanceFields(true)).mapToInt(f -> ((AnalysisField) f).getId()));
+ builder.setClassJavaName(type.toJavaName());
+ builder.setClassName(type.getName());
+ builder.setModifiers(type.getModifiers());
+ builder.setIsInterface(type.isInterface());
+ builder.setIsEnum(type.isEnum());
+ builder.setIsInitialized(type.isInitialized());
+ builder.setIsLinked(type.isLinked());
+ if (type.getSourceFileName() != null) {
+ builder.setSourceFileName(type.getSourceFileName());
}
- typeMap.put(FIELDS_TAG, fields);
- typeMap.put(CLASS_JAVA_NAME_TAG, type.toJavaName());
- typeMap.put(CLASS_NAME_TAG, type.getName());
- typeMap.put(MODIFIERS_TAG, type.getModifiers());
- typeMap.put(IS_INTERFACE_TAG, type.isInterface());
- typeMap.put(IS_ENUM_TAG, type.isEnum());
- typeMap.put(IS_INITIALIZED_TAG, type.isInitialized());
- typeMap.put(IS_LINKED_TAG, type.isLinked());
- typeMap.put(SOURCE_FILE_NAME_TAG, type.getSourceFileName());
try {
AnalysisType enclosingType = type.getEnclosingType();
if (enclosingType != null) {
- typeMap.put(ENCLOSING_TYPE_TAG, enclosingType.getId());
+ builder.setEnclosingTypeId(enclosingType.getId());
}
} catch (AnalysisError.TypeNotFoundError e) {
/*
@@ -396,106 +379,186 @@ protected void persistType(AnalysisType type, EconomicMap typeMa
*/
}
if (type.isArray()) {
- typeMap.put(COMPONENT_TYPE_TAG, type.getComponentType().getId());
+ builder.setComponentTypeId(type.getComponentType().getId());
}
if (type.getSuperclass() != null) {
- typeMap.put(SUPER_CLASS_TAG, type.getSuperclass().getId());
+ builder.setSuperClassTypeId(type.getSuperclass().getId());
}
- typeMap.put(INTERFACES_TAG, Arrays.stream(type.getInterfaces()).map(AnalysisType::getId).toList());
- typeMap.put(INSTANCE_FIELDS_TAG, Arrays.stream(type.getInstanceFields(false)).map(field -> ((AnalysisField) field).getId()).toList());
- typeMap.put(INSTANCE_FIELDS_WITH_SUPER_TAG, Arrays.stream(type.getInstanceFields(true)).map(field -> ((AnalysisField) field).getId()).toList());
- persistAnnotations(type, typeMap);
+ initInts(builder::initInterfaces, Arrays.stream(type.getInterfaces()).mapToInt(AnalysisType::getId));
+ initInts(builder::initInstanceFieldIds, Arrays.stream(type.getInstanceFields(false)).mapToInt(f -> ((AnalysisField) f).getId()));
+ initInts(builder::initInstanceFieldIdsWithSuper, Arrays.stream(type.getInstanceFields(true)).mapToInt(f -> ((AnalysisField) f).getId()));
+ initInts(builder::initStaticFieldIds, Arrays.stream(type.getStaticFields()).mapToInt(f -> ((AnalysisField) f).getId()));
+ persistAnnotations(type, builder::initAnnotationList);
- typeMap.put(IS_INSTANTIATED, type.isInstantiated());
- typeMap.put(IS_UNSAFE_ALLOCATED, type.isUnsafeAllocated());
- typeMap.put(IS_REACHABLE, type.isReachable());
+ builder.setIsInstantiated(type.isInstantiated());
+ builder.setIsUnsafeAllocated(type.isUnsafeAllocated());
+ builder.setIsReachable(type.isReachable());
- imageLayerWriterHelper.persistType(type, typeMap);
+ imageLayerWriterHelper.persistType(type, builder);
}
- /**
- * Some types can have an unstable name between two different image builds. To avoid producing
- * wrong results, a warning should be printed if such types exist in the resulting image.
- */
- @SuppressWarnings("unused")
- public void checkTypeStability(AnalysisType type) {
- /* Do not need to check anything here */
+ protected static void initInts(IntFunction builderSupplier, IntStream ids) {
+ int[] values = ids.toArray();
+ PrimitiveList.Int.Builder builder = builderSupplier.apply(values.length);
+ for (int i = 0; i < values.length; i++) {
+ builder.set(i, values[i]);
+ }
}
- public void persistMethod(AnalysisMethod method) {
- if (!persistedMethodIds.add(method.getId())) {
- return;
+ protected static void initStringList(IntFunction builderSupplier, Stream strings) {
+ Object[] array = strings.toArray();
+ TextList.Builder builder = builderSupplier.apply(array.length);
+ for (int i = 0; i < array.length; i++) {
+ builder.set(i, new Text.Reader(array[i].toString()));
}
- EconomicMap methodMap = getMethodMap(method);
- persistMethod(method, methodMap);
}
- protected void persistMethod(AnalysisMethod method, EconomicMap methodMap) {
+ protected void afterTypeAdded(AnalysisType type) {
+ /*
+ * Some persisted types are not reachable. In this case, the super class and interfaces have
+ * to be persisted manually as well.
+ */
+ if (type.getSuperclass() != null) {
+ ensureTypePersisted(type.getSuperclass());
+ }
+ for (AnalysisType iface : type.getInterfaces()) {
+ ensureTypePersisted(iface);
+ }
+ }
+
+ protected void afterMethodAdded(AnalysisMethod method) {
+ ensureTypePersisted(method.getSignature().getReturnType());
+ imageLayerWriterHelper.afterMethodAdded(method);
+ }
+
+ private void scanConstantReferencedObjects(ImageHeapConstant constant, Collection discoveredConstants) {
+ if (Objects.requireNonNull(constant) instanceof ImageHeapInstance instance) {
+ if (instance.isReaderInstalled()) {
+ scanConstantReferencedObjects(constant, instance.getFieldValues(), discoveredConstants);
+ }
+ } else if (constant instanceof ImageHeapObjectArray objArray) {
+ scanConstantReferencedObjects(constant, objArray.getElementValues(), discoveredConstants);
+ }
+ }
+
+ protected void scanConstantReferencedObjects(ImageHeapConstant constant, Object[] referencedObjects, Collection discoveredConstants) {
+ if (referencedObjects != null) {
+ for (int i = 0; i < referencedObjects.length; i++) {
+ AnalysisType parentType = constant.getType();
+ if (referencedObjects[i] instanceof ImageHeapConstant con && !constantsMap.containsKey(con)) {
+ /*
+ * Some constants are not in imageHeap#reachableObjects, but are still created
+ * in reachable constants. They can be created in the extension image, but
+ * should not be used.
+ */
+ Set relinkedFields = imageLayerSnapshotUtil.getRelinkedFields(parentType, aUniverse.getBigbang().getMetaAccess());
+ ConstantParent parent = relinkedFields.contains(i) ? new ConstantParent(getConstantId(constant), i) : ConstantParent.NONE;
+
+ discoveredConstants.add(con);
+ constantsMap.put(con, parent);
+ }
+ }
+ }
+ }
+
+ private void persistMethod(AnalysisMethod method, Supplier builderSupplier) {
+ persistMethod(method, builderSupplier.get());
+ }
+
+ protected void persistMethod(AnalysisMethod method, PersistedAnalysisMethod.Builder builder) {
+ MethodGraphsInfo graphsInfo = methodsMap.putIfAbsent(imageLayerSnapshotUtil.getMethodDescriptor(method), MethodGraphsInfo.NO_GRAPHS);
Executable executable = method.getJavaMethod();
- if (methodMap.containsKey(ID_TAG)) {
- throw GraalError.shouldNotReachHere("The method identifier should be unique, but " + imageLayerSnapshotUtil.getMethodIdentifier(method) + " got added twice.");
+ if (builder.getId() != 0) {
+ throw GraalError.shouldNotReachHere("The method descriptor should be unique, but " + imageLayerSnapshotUtil.getMethodDescriptor(method) + " got added twice.");
}
if (executable != null) {
- methodMap.put(ARGUMENTS_TAG, Arrays.stream(executable.getParameterTypes()).map(Class::getName).toList());
- methodMap.put(CLASS_NAME_TAG, executable.getDeclaringClass().getName());
- }
-
- persistType(method.getSignature().getReturnType());
-
- methodMap.put(TID_TAG, method.getDeclaringClass().getId());
- methodMap.put(ARGUMENT_IDS_TAG, method.getSignature().toParameterList(null).stream().map(AnalysisType::getId).toList());
- methodMap.put(ID_TAG, method.getId());
- methodMap.put(NAME_TAG, method.getName());
- methodMap.put(RETURN_TYPE_TAG, method.getSignature().getReturnType().getId());
- methodMap.put(IS_VAR_ARGS_TAG, method.isVarArgs());
- methodMap.put(CAN_BE_STATICALLY_BOUND_TAG, method.canBeStaticallyBound());
- methodMap.put(MODIFIERS_TAG, method.getModifiers());
- methodMap.put(IS_CONSTRUCTOR_TAG, method.isConstructor());
- methodMap.put(IS_SYNTHETIC_TAG, method.isSynthetic());
+ initStringList(builder::initArgumentClassNames, Arrays.stream(executable.getParameterTypes()).map(Class::getName));
+ builder.setClassName(executable.getDeclaringClass().getName());
+ }
+
+ builder.setDescriptor(imageLayerSnapshotUtil.getMethodDescriptor(method));
+ builder.setDeclaringTypeId(method.getDeclaringClass().getId());
+ initInts(builder::initArgumentTypeIds, method.getSignature().toParameterList(null).stream().mapToInt(AnalysisType::getId));
+ builder.setId(method.getId());
+ builder.setName(method.getName());
+ builder.setReturnTypeId(method.getSignature().getReturnType().getId());
+ builder.setIsVarArgs(method.isVarArgs());
+ builder.setCanBeStaticallyBound(method.canBeStaticallyBound());
+ builder.setModifiers(method.getModifiers());
+ builder.setIsConstructor(method.isConstructor());
+ builder.setIsSynthetic(method.isSynthetic());
byte[] code = method.getCode();
if (code != null) {
- methodMap.put(CODE_TAG, getString(JavaKind.Byte, method.getCode()));
+ builder.setCode(code);
}
- methodMap.put(CODE_SIZE_TAG, method.getCodeSize());
+ builder.setCodeSize(method.getCodeSize());
IntrinsicMethod intrinsicMethod = aUniverse.getBigbang().getConstantReflectionProvider().getMethodHandleAccess().lookupMethodHandleIntrinsic(method);
if (intrinsicMethod != null) {
- methodMap.put(METHOD_HANDLE_INTRINSIC_TAG, intrinsicMethod.name());
+ builder.setMethodHandleIntrinsicName(intrinsicMethod.name());
}
- persistAnnotations(method, methodMap);
+ persistAnnotations(method, builder::initAnnotationList);
+
+ builder.setIsVirtualRootMethod(method.isVirtualRootMethod());
+ builder.setIsDirectRootMethod(method.isDirectRootMethod());
+ builder.setIsInvoked(method.isSimplyInvoked());
+ builder.setIsImplementationInvoked(method.isSimplyImplementationInvoked());
+ builder.setIsIntrinsicMethod(method.isIntrinsicMethod());
- methodMap.put(IS_VIRTUAL_ROOT_METHOD, method.isVirtualRootMethod());
- methodMap.put(IS_DIRECT_ROOT_METHOD, method.isDirectRootMethod());
- methodMap.put(IS_INVOKED, method.isSimplyInvoked());
- methodMap.put(IS_IMPLEMENTATION_INVOKED, method.isSimplyImplementationInvoked());
- methodMap.put(IS_INTRINSIC_METHOD, method.isIntrinsicMethod());
+ if (graphsInfo != null && graphsInfo.analysisGraphLocation != null) {
+ builder.setAnalysisGraphLocation(graphsInfo.analysisGraphLocation);
+ builder.setAnalysisGraphIsIntrinsic(graphsInfo.analysisGraphIsIntrinsic);
+ }
+ if (graphsInfo != null && graphsInfo.strengthenedGraphLocation != null) {
+ builder.setStrengthenedGraphLocation(graphsInfo.strengthenedGraphLocation);
+ }
- imageLayerWriterHelper.persistMethod(method, methodMap);
+ imageLayerWriterHelper.persistMethod(method, builder);
}
public boolean isMethodPersisted(AnalysisMethod method) {
- String name = imageLayerSnapshotUtil.getMethodIdentifier(method);
+ String name = imageLayerSnapshotUtil.getMethodDescriptor(method);
return methodsMap.containsKey(name);
}
public void persistMethodGraphs() {
- for (AnalysisMethod method : aUniverse.getMethods()) {
- if (method.isTrackedAcrossLayers()) {
- persistAnalysisParsedGraph(method);
+ assert aUniverse.sealed();
+
+ aUniverse.getTypes().stream().filter(AnalysisType::isTrackedAcrossLayers)
+ .forEach(this::ensureTypePersisted);
+
+ aUniverse.getMethods().stream().filter(AnalysisMethod::isTrackedAcrossLayers)
+ .forEach(this::ensureMethodPersisted);
+
+ aUniverse.getFields().stream().filter(AnalysisField::isTrackedAcrossLayers)
+ .forEach(this::ensureFieldPersisted);
+
+ // Persisting graphs discovers additional types, members and constants that need persisting
+ Set persistedGraphMethods = new HashSet<>();
+ do {
+ for (AnalysisMethod method : methodsToPersist) {
+ if (persistedGraphMethods.add(method)) {
+ persistAnalysisParsedGraph(method);
+ }
}
- }
- }
+ } while (!persistedGraphMethods.equals(methodsToPersist));
+
+ // Note that constants are scanned late so all values are available.
- public void persistAnalysisParsedGraph(AnalysisMethod method) {
- EconomicMap methodMap = getMethodMap(method);
+ sealed = true;
+ }
+ private void persistAnalysisParsedGraph(AnalysisMethod method) {
Object analyzedGraph = method.getGraph();
if (analyzedGraph instanceof AnalysisParsedGraph analysisParsedGraph) {
- if (!methodMap.containsKey(INTRINSIC_TAG)) {
- if (!persistGraph(method, analysisParsedGraph.getEncodedGraph(), methodMap, ANALYSIS_PARSED_GRAPH_TAG)) {
- return;
+ String name = imageLayerSnapshotUtil.getMethodDescriptor(method);
+ MethodGraphsInfo graphsInfo = methodsMap.get(name);
+ if (graphsInfo == null || graphsInfo.analysisGraphLocation == null) {
+ String location = persistGraph(method, analysisParsedGraph.getEncodedGraph());
+ if (location != null) {
+ methodsMap.compute(name, (n, mgi) -> (mgi != null ? mgi : MethodGraphsInfo.NO_GRAPHS)
+ .withAnalysisGraph(location, analysisParsedGraph.isIntrinsic()));
}
- methodMap.put(INTRINSIC_TAG, analysisParsedGraph.isIntrinsic());
}
}
}
@@ -505,25 +568,25 @@ public void persistMethodStrengthenedGraph(AnalysisMethod method) {
return;
}
- EconomicMap methodMap = getMethodMap(method);
+ String name = imageLayerSnapshotUtil.getMethodDescriptor(method);
+ MethodGraphsInfo graphsInfo = methodsMap.get(name);
- if (!methodMap.containsKey(STRENGTHENED_GRAPH_TAG)) {
+ if (graphsInfo == null || graphsInfo.strengthenedGraphLocation == null) {
EncodedGraph analyzedGraph = method.getAnalyzedGraph();
- persistGraph(method, analyzedGraph, methodMap, STRENGTHENED_GRAPH_TAG);
+ String location = persistGraph(method, analyzedGraph);
+ methodsMap.compute(name, (n, mgi) -> (mgi != null ? mgi : MethodGraphsInfo.NO_GRAPHS).withStrengthenedGraph(location));
}
}
- private boolean persistGraph(AnalysisMethod method, EncodedGraph analyzedGraph, EconomicMap methodMap, String graphTag) {
+ private String persistGraph(AnalysisMethod method, EncodedGraph analyzedGraph) {
if (!useSharedLayerGraphs) {
- return false;
+ return null;
}
byte[] encodedGraph = ObjectCopier.encode(imageLayerSnapshotUtil.getGraphEncoder(this), analyzedGraph);
if (contains(encodedGraph, LambdaUtils.LAMBDA_CLASS_NAME_SUBSTRING.getBytes(StandardCharsets.UTF_8))) {
throw AnalysisError.shouldNotReachHere("The graph for the method %s contains a reference to a lambda type, which cannot be decoded: %s".formatted(method, encodedGraph));
}
- String location = graphsOutput.add(encodedGraph);
- methodMap.put(graphTag, location);
- return true;
+ return graphsOutput.add(encodedGraph);
}
private static boolean contains(byte[] data, byte[] seq) {
@@ -538,84 +601,67 @@ private static boolean contains(byte[] data, byte[] seq) {
return false;
}
- private EconomicMap getMethodMap(AnalysisMethod method) {
- String name = imageLayerSnapshotUtil.getMethodIdentifier(method);
- EconomicMap methodMap = methodsMap.get(name);
- if (methodMap == null) {
- methodMap = EconomicMap.create();
- methodsMap.put(name, methodMap);
- }
- return methodMap;
- }
-
- protected void persistField(AnalysisField field) {
- EconomicMap fieldMap = EconomicMap.create();
+ private void persistField(AnalysisField field, Supplier fieldBuilderSupplier) {
+ PersistedAnalysisField.Builder builder = fieldBuilderSupplier.get();
- persistField(field, fieldMap);
+ persistField(field, builder);
Field originalField = OriginalFieldProvider.getJavaField(field);
if (originalField != null && !originalField.getDeclaringClass().equals(field.getDeclaringClass().getJavaClass())) {
- fieldMap.put(CLASS_NAME_TAG, originalField.getDeclaringClass().getName());
+ builder.setClassName(originalField.getDeclaringClass().getName());
}
- fieldMap.put(IS_STATIC_TAG, field.isStatic());
- fieldMap.put(IS_INTERNAL_TAG, field.isInternal());
- fieldMap.put(IS_SYNTHETIC_TAG, field.isSynthetic());
- fieldMap.put(FIELD_TYPE_TAG, field.getType().getId());
- fieldMap.put(MODIFIERS_TAG, field.getModifiers());
- fieldMap.put(POSITION_TAG, field.getPosition());
- persistAnnotations(field, fieldMap);
+ builder.setIsStatic(field.isStatic());
+ builder.setIsInternal(field.isInternal());
+ builder.setIsSynthetic(field.isSynthetic());
+ builder.setTypeId(field.getType().getId());
+ builder.setModifiers(field.getModifiers());
+ builder.setPosition(field.getPosition());
- String tid = String.valueOf(field.getDeclaringClass().getId());
- fieldsMap.computeIfAbsent(tid, key -> new ConcurrentHashMap<>()).put(field.getName(), fieldMap);
+ persistAnnotations(field, builder::initAnnotationList);
}
- protected void persistField(AnalysisField field, EconomicMap fieldMap) {
- fieldMap.put(ID_TAG, field.getId());
- fieldMap.put(FIELD_ACCESSED_TAG, field.getAccessedReason() != null);
- fieldMap.put(FIELD_READ_TAG, field.getReadReason() != null);
- fieldMap.put(FIELD_WRITTEN_TAG, field.getWrittenReason() != null);
- fieldMap.put(FIELD_FOLDED_TAG, field.getFoldedReason() != null);
- }
-
- protected void persistConstant(int parentId, int index, ImageHeapConstant imageHeapConstant) {
- if (!constantsMap.containsKey(Integer.toString(getConstantId(imageHeapConstant)))) {
- EconomicMap constantMap = EconomicMap.create();
- persistConstant(parentId, index, imageHeapConstant, constantMap);
- }
+ protected void persistField(AnalysisField field, PersistedAnalysisField.Builder builder) {
+ builder.setId(field.getId());
+ builder.setDeclaringTypeId(field.getDeclaringClass().getId());
+ builder.setName(field.getName());
+ builder.setIsAccessed(field.getAccessedReason() != null);
+ builder.setIsRead(field.getReadReason() != null);
+ builder.setIsWritten(field.getWrittenReason() != null);
+ builder.setIsFolded(field.getFoldedReason() != null);
}
- protected void persistConstant(int parentId, int index, ImageHeapConstant imageHeapConstant, EconomicMap constantMap) {
+ protected void persistConstant(ImageHeapConstant imageHeapConstant, ConstantParent parent, PersistedConstant.Builder builder, Set constantsToRelink) {
int id = getConstantId(imageHeapConstant);
- constantsMap.put(Integer.toString(id), constantMap);
- constantMap.put(TID_TAG, imageHeapConstant.getType().getId());
+ builder.setId(id);
+ builder.setTypeId(imageHeapConstant.getType().getId());
IdentityHashCodeProvider identityHashCodeProvider = (IdentityHashCodeProvider) aUniverse.getBigbang().getConstantReflectionProvider();
int identityHashCode = identityHashCodeProvider.identityHashCode(imageHeapConstant);
- constantMap.put(IDENTITY_HASH_CODE_TAG, identityHashCode);
+ builder.setIdentityHashCode(identityHashCode);
switch (imageHeapConstant) {
case ImageHeapInstance imageHeapInstance -> {
+ builder.initObject().setInstance(Void.VOID);
Object[] fieldValues = imageHeapInstance.isReaderInstalled() ? imageHeapInstance.getFieldValues() : null;
- persistConstant(id, imageHeapConstant.getType(), constantMap, INSTANCE_TAG, fieldValues);
- persistConstantRelinkingInfo(constantMap, imageHeapConstant, aUniverse.getBigbang());
+ persistConstantObjectData(builder.getObject(), fieldValues);
+ persistConstantRelinkingInfo(builder, imageHeapConstant, constantsToRelink, aUniverse.getBigbang());
}
- case ImageHeapObjectArray imageHeapObjectArray ->
- persistConstant(id, imageHeapConstant.getType(), constantMap, ARRAY_TAG, imageHeapObjectArray.getElementValues());
- case ImageHeapPrimitiveArray imageHeapPrimitiveArray -> {
- constantMap.put(CONSTANT_TYPE_TAG, PRIMITIVE_ARRAY_TAG);
- constantMap.put(DATA_TAG, getString(imageHeapPrimitiveArray.getType().getComponentType().getJavaKind(), imageHeapPrimitiveArray.getArray()));
+ case ImageHeapObjectArray imageHeapObjectArray -> {
+ builder.initObject().setObjectArray(Void.VOID);
+ persistConstantObjectData(builder.getObject(), imageHeapObjectArray.getElementValues());
}
+ case ImageHeapPrimitiveArray imageHeapPrimitiveArray ->
+ persistConstantPrimitiveArray(builder.initPrimitiveData(), imageHeapPrimitiveArray.getType().getComponentType().getJavaKind(), imageHeapPrimitiveArray.getArray());
case ImageHeapRelocatableConstant relocatableConstant -> {
- constantMap.put(CONSTANT_TYPE_TAG, RELOCATED_CONSTANT_TAG);
- constantMap.put(DATA_TAG, relocatableConstant.getConstantData().key);
+ builder.initRelocatable().setKey(relocatableConstant.getConstantData().key);
}
default -> throw AnalysisError.shouldNotReachHere("Unexpected constant type " + imageHeapConstant);
}
- if (!constantsToRelink.contains(id) && parentId != UNDEFINED_CONSTANT_ID) {
- constantMap.put(PARENT_CONSTANT_ID_TAG, parentId);
- assert index != UNDEFINED_FIELD_INDEX : "Tried to persist child constant %s from parent constant %d, but got index %d".formatted(imageHeapConstant, parentId, index);
- constantMap.put(PARENT_CONSTANT_INDEX_TAG, index);
+ if (!constantsToRelink.contains(id) && parent != ConstantParent.NONE) {
+ builder.setParentConstantId(parent.constantId);
+ assert parent.index != UNDEFINED_FIELD_INDEX : "Tried to persist child constant %s from parent constant %d, but got index %d".formatted(imageHeapConstant, parent.constantId, parent.index);
+ builder.setParentIndex(parent.index);
}
}
@@ -623,97 +669,90 @@ protected int getConstantId(ImageHeapConstant imageHeapConstant) {
return imageHeapConstant.constantData.id;
}
- public void persistConstantRelinkingInfo(EconomicMap constantMap, ImageHeapConstant imageHeapConstant, BigBang bb) {
+ private void persistConstantRelinkingInfo(PersistedConstant.Builder builder, ImageHeapConstant imageHeapConstant, Set constantsToRelink, BigBang bb) {
Class clazz = imageHeapConstant.getType().getJavaClass();
JavaConstant hostedObject = imageHeapConstant.getHostedObject();
boolean simulated = hostedObject == null;
- constantMap.put(SIMULATED_TAG, simulated);
+ builder.setIsSimulated(simulated);
if (!simulated) {
- persistConstantRelinkingInfo(constantMap, bb, clazz, hostedObject, imageHeapConstant.constantData.id);
+ persistConstantRelinkingInfo(builder.getObject().getRelinking(), bb, clazz, hostedObject, imageHeapConstant.constantData.id, constantsToRelink);
}
}
- public void persistConstantRelinkingInfo(EconomicMap constantMap, BigBang bb, Class clazz, JavaConstant hostedObject, int id) {
+ protected void persistConstantRelinkingInfo(PersistedConstant.Object.Relinking.Builder builder, BigBang bb, Class clazz, JavaConstant hostedObject, int id, Set constantsToRelink) {
if (clazz.equals(String.class)) {
+ StringConstant.Builder stringConstantBuilder = builder.initStringConstant();
String value = bb.getSnippetReflectionProvider().asObject(String.class, hostedObject);
if (internedStringsIdentityMap.containsKey(value)) {
/*
* Interned strings must be relinked.
*/
- constantMap.put(VALUE_TAG, value);
+ stringConstantBuilder.setValue(value);
constantsToRelink.add(id);
}
} else if (Enum.class.isAssignableFrom(clazz)) {
+ EnumConstant.Builder enumBuilder = builder.initEnumConstant();
Enum value = bb.getSnippetReflectionProvider().asObject(Enum.class, hostedObject);
- constantMap.put(ENUM_CLASS_TAG, value.getDeclaringClass().getName());
- constantMap.put(ENUM_NAME_TAG, value.name());
+ enumBuilder.setEnumClass(value.getDeclaringClass().getName());
+ enumBuilder.setEnumName(value.name());
constantsToRelink.add(id);
}
}
- private static List getString(JavaKind kind, Object arrayObject) {
- return switch (kind) {
- case Boolean -> IntStream.range(0, ((boolean[]) arrayObject).length).mapToObj(idx -> ((boolean[]) arrayObject)[idx]).toList();
- case Byte -> IntStream.range(0, ((byte[]) arrayObject).length).mapToObj(idx -> ((byte[]) arrayObject)[idx]).toList();
- case Short -> IntStream.range(0, ((short[]) arrayObject).length).mapToObj(idx -> ((short[]) arrayObject)[idx]).toList();
- case Char -> new String((char[]) arrayObject).chars().boxed().toList();
- case Int -> Arrays.stream((int[]) arrayObject).boxed().toList();
- /* Have to persist it as a String as it would be converted to an Integer otherwise */
- case Long -> Arrays.stream(((long[]) arrayObject)).mapToObj(String::valueOf).toList();
- /* Have to persist it as a String as it would be converted to a Double otherwise */
- case Float -> IntStream.range(0, ((float[]) arrayObject).length).mapToObj(idx -> String.valueOf(((float[]) arrayObject)[idx])).toList();
- case Double -> Arrays.stream(((double[]) arrayObject)).mapToObj(String::valueOf).toList();
- default -> throw new IllegalArgumentException("Unsupported kind: " + kind);
- };
+ private static void persistConstantPrimitiveArray(PersistedConstant.PrimitiveData.Builder builder, JavaKind componentKind, Object array) {
+ assert componentKind.toJavaClass().equals(array.getClass().getComponentType());
+ switch (array) {
+ case boolean[] a -> persistArray(a, builder::initZ, (b, i) -> b.set(i, a[i]));
+ case byte[] a -> persistArray(a, builder::initB, (b, i) -> b.set(i, a[i]));
+ case short[] a -> persistArray(a, builder::initS, (b, i) -> b.set(i, a[i]));
+ case char[] a -> persistArray(a, builder::initC, (b, i) -> b.set(i, (short) a[i]));
+ case int[] a -> persistArray(a, builder::initI, (b, i) -> b.set(i, a[i]));
+ case long[] a -> persistArray(a, builder::initJ, (b, i) -> b.set(i, a[i]));
+ case float[] a -> persistArray(a, builder::initF, (b, i) -> b.set(i, a[i]));
+ case double[] a -> persistArray(a, builder::initD, (b, i) -> b.set(i, a[i]));
+ default -> throw new IllegalArgumentException("Unsupported kind: " + componentKind);
+ }
+ }
+
+ /** Enables concise one-liners in {@link #persistConstantPrimitiveArray}. */
+ private static void persistArray(A array, IntFunction init, ObjIntConsumer setter) {
+ int length = Array.getLength(array);
+ T builder = init.apply(length);
+ for (int i = 0; i < length; i++) {
+ setter.accept(builder, i);
+ }
}
- protected void persistConstant(int id, AnalysisType type, EconomicMap constantMap, String constantType, Object[] values) {
- constantMap.put(CONSTANT_TYPE_TAG, constantType);
+ private void persistConstantObjectData(PersistedConstant.Object.Builder builder, Object[] values) {
if (values != null) {
- List> data = new ArrayList<>();
+ StructList.Builder refsBuilder = builder.initData(values.length);
for (int i = 0; i < values.length; ++i) {
Object object = values[i];
- if (delegateProcessing(data, object)) {
+ ConstantReference.Builder b = refsBuilder.get(i);
+ if (delegateProcessing(b, object)) {
/* The object was already persisted */
} else if (object instanceof ImageHeapConstant imageHeapConstant) {
- data.add(List.of(OBJECT_TAG, getConstantId(imageHeapConstant)));
- /*
- * Some constants are not in imageHeap#reachableObjects, but are still created
- * in reachable constants. They can be created in the extension image, but
- * should not be used.
- */
- persistConstant(imageLayerSnapshotUtil.getRelinkedFields(type, aUniverse.getBigbang().getMetaAccess()).contains(i) ? id : UNDEFINED_CONSTANT_ID, i, imageHeapConstant);
+ assert constantsMap.containsKey(imageHeapConstant);
+ b.initObjectConstant().setConstantId(getConstantId(imageHeapConstant));
} else if (object == JavaConstant.NULL_POINTER) {
- data.add(List.of(OBJECT_TAG, NULL_POINTER_CONSTANT));
- } else if (object instanceof PrimitiveConstant primitiveConstant) {
- JavaKind kind = primitiveConstant.getJavaKind();
- data.add(List.of(kind.getTypeChar(), getPrimitiveConstantValue(primitiveConstant, kind)));
+ b.setNullPointer(Void.VOID);
+ } else if (object instanceof PrimitiveConstant pc) {
+ ConstantReference.PrimitiveValue.Builder pb = b.initPrimitiveValue();
+ pb.setTypeChar(NumUtil.safeToUByte(pc.getJavaKind().getTypeChar()));
+ pb.setRawValue(pc.getRawValue());
} else {
AnalysisError.guarantee(object instanceof AnalysisFuture, "Unexpected constant %s", object);
- data.add(List.of(OBJECT_TAG, NOT_MATERIALIZED_CONSTANT));
+ b.setNotMaterialized(Void.VOID);
}
}
- constantMap.put(DATA_TAG, data);
}
}
- private static Object getPrimitiveConstantValue(PrimitiveConstant primitiveConstant, JavaKind kind) {
- return switch (kind) {
- case Boolean, Byte, Short, Int, Double -> primitiveConstant.getRawValue();
- /*
- * Have to persist it as a String as it would be converted to an Integer or a Double
- * otherwise
- */
- case Char, Long, Float -> String.valueOf(primitiveConstant.getRawValue());
- default -> throw new IllegalArgumentException("Unsupported kind: " + kind);
- };
- }
-
/**
* Hook for subclasses to do their own processing.
*/
@SuppressWarnings("unused")
- protected boolean delegateProcessing(List> data, Object constant) {
+ protected boolean delegateProcessing(ConstantReference.Builder builder, Object constant) {
return false;
}
}
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriterHelper.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriterHelper.java
index 9a942a6ca894..a5088f451984 100644
--- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriterHelper.java
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageLayerWriterHelper.java
@@ -24,8 +24,8 @@
*/
package com.oracle.graal.pointsto.heap;
-import org.graalvm.collections.EconomicMap;
-
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisMethod;
+import com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.PersistedAnalysisType;
import com.oracle.graal.pointsto.meta.AnalysisMethod;
import com.oracle.graal.pointsto.meta.AnalysisType;
@@ -37,12 +37,16 @@ public ImageLayerWriterHelper(ImageLayerWriter imageLayerWriter) {
}
@SuppressWarnings("unused")
- protected void persistType(AnalysisType type, EconomicMap typeMap) {
+ protected void persistType(AnalysisType type, PersistedAnalysisType.Builder builder) {
/* No additional information to persist */
}
@SuppressWarnings("unused")
- protected void persistMethod(AnalysisMethod method, EconomicMap methodMap) {
+ protected void persistMethod(AnalysisMethod method, PersistedAnalysisMethod.Builder builder) {
/* No additional information to persist */
}
+
+ @SuppressWarnings("unused")
+ protected void afterMethodAdded(AnalysisMethod method) {
+ }
}
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/SharedLayerSnapshotCapnProtoSchemaHolder.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/SharedLayerSnapshotCapnProtoSchemaHolder.java
new file mode 100644
index 000000000000..abb56adb9e84
--- /dev/null
+++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/SharedLayerSnapshotCapnProtoSchemaHolder.java
@@ -0,0 +1,4676 @@
+/*
+ * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+//@formatter:off
+//Checkstyle: stop
+// Generated by Cap'n Proto compiler, DO NOT EDIT
+// source: SharedLayerSnapshotCapnProtoSchema.capnp
+
+package com.oracle.graal.pointsto.heap;
+
+@SuppressWarnings("all")
+public final class SharedLayerSnapshotCapnProtoSchemaHolder {
+ public static class PersistedAnalysisType {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)4,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisType.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getId() {
+ return _getIntField(0);
+ }
+ public final void setId(int value) {
+ _setIntField(0, value);
+ }
+
+ public final boolean hasDescriptor() {
+ return !_pointerFieldIsNull(0);
+ }
+ public final org.capnproto.Text.Builder getDescriptor() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+ public final void setDescriptor(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 0, value);
+ }
+ public final void setDescriptor(String value) {
+ _setPointerField(org.capnproto.Text.factory, 0, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initDescriptor(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 0, size);
+ }
+ public final boolean hasFields() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getFields() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 1, null, 0);
+ }
+ public final void setFields(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 1, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initFields(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 1, size);
+ }
+ public final int getHubIdentityHashCode() {
+ return _getIntField(1);
+ }
+ public final void setHubIdentityHashCode(int value) {
+ _setIntField(1, value);
+ }
+
+ public final boolean hasClassJavaName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public final org.capnproto.Text.Builder getClassJavaName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+ public final void setClassJavaName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 2, value);
+ }
+ public final void setClassJavaName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 2, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initClassJavaName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 2, size);
+ }
+ public final boolean hasClassName() {
+ return !_pointerFieldIsNull(3);
+ }
+ public final org.capnproto.Text.Builder getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 3, null, 0, 0);
+ }
+ public final void setClassName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 3, value);
+ }
+ public final void setClassName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 3, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initClassName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 3, size);
+ }
+ public final int getModifiers() {
+ return _getIntField(2);
+ }
+ public final void setModifiers(int value) {
+ _setIntField(2, value);
+ }
+
+ public final boolean getIsInterface() {
+ return _getBooleanField(96);
+ }
+ public final void setIsInterface(boolean value) {
+ _setBooleanField(96, value);
+ }
+
+ public final boolean getIsEnum() {
+ return _getBooleanField(97);
+ }
+ public final void setIsEnum(boolean value) {
+ _setBooleanField(97, value);
+ }
+
+ public final boolean getIsInitialized() {
+ return _getBooleanField(98);
+ }
+ public final void setIsInitialized(boolean value) {
+ _setBooleanField(98, value);
+ }
+
+ public final boolean getIsInitializedAtBuildTime() {
+ return _getBooleanField(99);
+ }
+ public final void setIsInitializedAtBuildTime(boolean value) {
+ _setBooleanField(99, value);
+ }
+
+ public final boolean getIsLinked() {
+ return _getBooleanField(100);
+ }
+ public final void setIsLinked(boolean value) {
+ _setBooleanField(100, value);
+ }
+
+ public final boolean hasSourceFileName() {
+ return !_pointerFieldIsNull(4);
+ }
+ public final org.capnproto.Text.Builder getSourceFileName() {
+ return _getPointerField(org.capnproto.Text.factory, 4, null, 0, 0);
+ }
+ public final void setSourceFileName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 4, value);
+ }
+ public final void setSourceFileName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 4, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initSourceFileName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 4, size);
+ }
+ public final int getEnclosingTypeId() {
+ return _getIntField(4);
+ }
+ public final void setEnclosingTypeId(int value) {
+ _setIntField(4, value);
+ }
+
+ public final int getComponentTypeId() {
+ return _getIntField(5);
+ }
+ public final void setComponentTypeId(int value) {
+ _setIntField(5, value);
+ }
+
+ public final int getSuperClassTypeId() {
+ return _getIntField(6);
+ }
+ public final void setSuperClassTypeId(int value) {
+ _setIntField(6, value);
+ }
+
+ public final boolean getIsInstantiated() {
+ return _getBooleanField(101);
+ }
+ public final void setIsInstantiated(boolean value) {
+ _setBooleanField(101, value);
+ }
+
+ public final boolean getIsUnsafeAllocated() {
+ return _getBooleanField(102);
+ }
+ public final void setIsUnsafeAllocated(boolean value) {
+ _setBooleanField(102, value);
+ }
+
+ public final boolean getIsReachable() {
+ return _getBooleanField(103);
+ }
+ public final void setIsReachable(boolean value) {
+ _setBooleanField(103, value);
+ }
+
+ public final boolean hasInterfaces() {
+ return !_pointerFieldIsNull(5);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getInterfaces() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 5, null, 0);
+ }
+ public final void setInterfaces(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 5, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initInterfaces(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 5, size);
+ }
+ public final boolean hasInstanceFieldIds() {
+ return !_pointerFieldIsNull(6);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getInstanceFieldIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 6, null, 0);
+ }
+ public final void setInstanceFieldIds(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 6, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initInstanceFieldIds(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 6, size);
+ }
+ public final boolean hasInstanceFieldIdsWithSuper() {
+ return !_pointerFieldIsNull(7);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getInstanceFieldIdsWithSuper() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 7, null, 0);
+ }
+ public final void setInstanceFieldIdsWithSuper(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 7, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initInstanceFieldIdsWithSuper(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 7, size);
+ }
+ public final boolean hasStaticFieldIds() {
+ return !_pointerFieldIsNull(8);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getStaticFieldIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 8, null, 0);
+ }
+ public final void setStaticFieldIds(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 8, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initStaticFieldIds(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 8, size);
+ }
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(9);
+ }
+ public final org.capnproto.StructList.Builder getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 9, null, 0);
+ }
+ public final void setAnnotationList(org.capnproto.StructList.Reader value) {
+ _setPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 9, value);
+ }
+ public final org.capnproto.StructList.Builder initAnnotationList(int size) {
+ return _initPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 9, size);
+ }
+ public final com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.Builder getClassInitializationInfo() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.factory, 10, null, 0);
+ }
+ public final void setClassInitializationInfo(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.Reader value) {
+ _setPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.factory,10, value);
+ }
+ public final com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.Builder initClassInitializationInfo() {
+ return _initPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.factory,10, 0);
+ }
+ public final WrappedType.Builder getWrappedType() {
+ return new PersistedAnalysisType.WrappedType.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final WrappedType.Builder initWrappedType() {
+ _setShortField(7,(short)0);
+ _clearPointerField(11);
+ _clearPointerField(12);
+ return new PersistedAnalysisType.WrappedType.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getId() {
+ return _getIntField(0);
+ }
+
+ public boolean hasDescriptor() {
+ return !_pointerFieldIsNull(0);
+ }
+ public org.capnproto.Text.Reader getDescriptor() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+
+ public final boolean hasFields() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getFields() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 1, null, 0);
+ }
+
+ public final int getHubIdentityHashCode() {
+ return _getIntField(1);
+ }
+
+ public boolean hasClassJavaName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public org.capnproto.Text.Reader getClassJavaName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+
+ public boolean hasClassName() {
+ return !_pointerFieldIsNull(3);
+ }
+ public org.capnproto.Text.Reader getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 3, null, 0, 0);
+ }
+
+ public final int getModifiers() {
+ return _getIntField(2);
+ }
+
+ public final boolean getIsInterface() {
+ return _getBooleanField(96);
+ }
+
+ public final boolean getIsEnum() {
+ return _getBooleanField(97);
+ }
+
+ public final boolean getIsInitialized() {
+ return _getBooleanField(98);
+ }
+
+ public final boolean getIsInitializedAtBuildTime() {
+ return _getBooleanField(99);
+ }
+
+ public final boolean getIsLinked() {
+ return _getBooleanField(100);
+ }
+
+ public boolean hasSourceFileName() {
+ return !_pointerFieldIsNull(4);
+ }
+ public org.capnproto.Text.Reader getSourceFileName() {
+ return _getPointerField(org.capnproto.Text.factory, 4, null, 0, 0);
+ }
+
+ public final int getEnclosingTypeId() {
+ return _getIntField(4);
+ }
+
+ public final int getComponentTypeId() {
+ return _getIntField(5);
+ }
+
+ public final int getSuperClassTypeId() {
+ return _getIntField(6);
+ }
+
+ public final boolean getIsInstantiated() {
+ return _getBooleanField(101);
+ }
+
+ public final boolean getIsUnsafeAllocated() {
+ return _getBooleanField(102);
+ }
+
+ public final boolean getIsReachable() {
+ return _getBooleanField(103);
+ }
+
+ public final boolean hasInterfaces() {
+ return !_pointerFieldIsNull(5);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getInterfaces() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 5, null, 0);
+ }
+
+ public final boolean hasInstanceFieldIds() {
+ return !_pointerFieldIsNull(6);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getInstanceFieldIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 6, null, 0);
+ }
+
+ public final boolean hasInstanceFieldIdsWithSuper() {
+ return !_pointerFieldIsNull(7);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getInstanceFieldIdsWithSuper() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 7, null, 0);
+ }
+
+ public final boolean hasStaticFieldIds() {
+ return !_pointerFieldIsNull(8);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getStaticFieldIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 8, null, 0);
+ }
+
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(9);
+ }
+ public final org.capnproto.StructList.Reader getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 9, null, 0);
+ }
+
+ public boolean hasClassInitializationInfo() {
+ return !_pointerFieldIsNull(10);
+ }
+ public com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.Reader getClassInitializationInfo() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.ClassInitializationInfo.factory,10,null, 0);
+ }
+
+ public WrappedType.Reader getWrappedType() {
+ return new PersistedAnalysisType.WrappedType.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ }
+
+ public static class WrappedType {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)4,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisType.WrappedType.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public Which which() {
+ switch(_getShortField(7)) {
+ case 0 : return Which.NONE;
+ case 1 : return Which.SERIALIZATION_GENERATED;
+ case 2 : return Which.LAMBDA;
+ case 3 : return Which.PROXY_TYPE;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean isNone() {
+ return which() == PersistedAnalysisType.WrappedType.Which.NONE;
+ }
+ public final org.capnproto.Void getNone() {
+ assert which() == PersistedAnalysisType.WrappedType.Which.NONE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setNone(org.capnproto.Void value) {
+ _setShortField(7, (short)PersistedAnalysisType.WrappedType.Which.NONE.ordinal());
+ }
+
+ public final boolean isSerializationGenerated() {
+ return which() == PersistedAnalysisType.WrappedType.Which.SERIALIZATION_GENERATED;
+ }
+ public final SerializationGenerated.Builder getSerializationGenerated() {
+ return new PersistedAnalysisType.WrappedType.SerializationGenerated.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final SerializationGenerated.Builder initSerializationGenerated() {
+ _setShortField(7, (short)PersistedAnalysisType.WrappedType.Which.SERIALIZATION_GENERATED.ordinal());
+ _clearPointerField(11);
+ _clearPointerField(12);
+ return new PersistedAnalysisType.WrappedType.SerializationGenerated.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isLambda() {
+ return which() == PersistedAnalysisType.WrappedType.Which.LAMBDA;
+ }
+ public final Lambda.Builder getLambda() {
+ return new PersistedAnalysisType.WrappedType.Lambda.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Lambda.Builder initLambda() {
+ _setShortField(7, (short)PersistedAnalysisType.WrappedType.Which.LAMBDA.ordinal());
+ _clearPointerField(11);
+ return new PersistedAnalysisType.WrappedType.Lambda.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isProxyType() {
+ return which() == PersistedAnalysisType.WrappedType.Which.PROXY_TYPE;
+ }
+ public final org.capnproto.Void getProxyType() {
+ assert which() == PersistedAnalysisType.WrappedType.Which.PROXY_TYPE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setProxyType(org.capnproto.Void value) {
+ _setShortField(7, (short)PersistedAnalysisType.WrappedType.Which.PROXY_TYPE.ordinal());
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public Which which() {
+ switch(_getShortField(7)) {
+ case 0 : return Which.NONE;
+ case 1 : return Which.SERIALIZATION_GENERATED;
+ case 2 : return Which.LAMBDA;
+ case 3 : return Which.PROXY_TYPE;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final boolean isNone() {
+ return which() == PersistedAnalysisType.WrappedType.Which.NONE;
+ }
+ public final org.capnproto.Void getNone() {
+ assert which() == PersistedAnalysisType.WrappedType.Which.NONE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public final boolean isSerializationGenerated() {
+ return which() == PersistedAnalysisType.WrappedType.Which.SERIALIZATION_GENERATED;
+ }
+ public SerializationGenerated.Reader getSerializationGenerated() {
+ return new PersistedAnalysisType.WrappedType.SerializationGenerated.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isLambda() {
+ return which() == PersistedAnalysisType.WrappedType.Which.LAMBDA;
+ }
+ public Lambda.Reader getLambda() {
+ return new PersistedAnalysisType.WrappedType.Lambda.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isProxyType() {
+ return which() == PersistedAnalysisType.WrappedType.Which.PROXY_TYPE;
+ }
+ public final org.capnproto.Void getProxyType() {
+ assert which() == PersistedAnalysisType.WrappedType.Which.PROXY_TYPE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ }
+
+ public enum Which {
+ NONE,
+ SERIALIZATION_GENERATED,
+ LAMBDA,
+ PROXY_TYPE,
+ _NOT_IN_SCHEMA,
+ }
+ public static class SerializationGenerated {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)4,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisType.WrappedType.SerializationGenerated.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean hasRawDeclaringClass() {
+ return !_pointerFieldIsNull(11);
+ }
+ public final org.capnproto.Text.Builder getRawDeclaringClass() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+ public final void setRawDeclaringClass(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 11, value);
+ }
+ public final void setRawDeclaringClass(String value) {
+ _setPointerField(org.capnproto.Text.factory, 11, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initRawDeclaringClass(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 11, size);
+ }
+ public final boolean hasRawTargetConstructor() {
+ return !_pointerFieldIsNull(12);
+ }
+ public final org.capnproto.Text.Builder getRawTargetConstructor() {
+ return _getPointerField(org.capnproto.Text.factory, 12, null, 0, 0);
+ }
+ public final void setRawTargetConstructor(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 12, value);
+ }
+ public final void setRawTargetConstructor(String value) {
+ _setPointerField(org.capnproto.Text.factory, 12, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initRawTargetConstructor(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 12, size);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public boolean hasRawDeclaringClass() {
+ return !_pointerFieldIsNull(11);
+ }
+ public org.capnproto.Text.Reader getRawDeclaringClass() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+
+ public boolean hasRawTargetConstructor() {
+ return !_pointerFieldIsNull(12);
+ }
+ public org.capnproto.Text.Reader getRawTargetConstructor() {
+ return _getPointerField(org.capnproto.Text.factory, 12, null, 0, 0);
+ }
+
+ }
+
+ }
+
+
+ public static class Lambda {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)4,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisType.WrappedType.Lambda.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean hasCapturingClass() {
+ return !_pointerFieldIsNull(11);
+ }
+ public final org.capnproto.Text.Builder getCapturingClass() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+ public final void setCapturingClass(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 11, value);
+ }
+ public final void setCapturingClass(String value) {
+ _setPointerField(org.capnproto.Text.factory, 11, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initCapturingClass(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 11, size);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public boolean hasCapturingClass() {
+ return !_pointerFieldIsNull(11);
+ }
+ public org.capnproto.Text.Reader getCapturingClass() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ public static class ClassInitializationInfo {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return ClassInitializationInfo.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean getIsNoInitializerNoTracking() {
+ return _getBooleanField(0);
+ }
+ public final void setIsNoInitializerNoTracking(boolean value) {
+ _setBooleanField(0, value);
+ }
+
+ public final boolean getIsInitializedNoTracking() {
+ return _getBooleanField(1);
+ }
+ public final void setIsInitializedNoTracking(boolean value) {
+ _setBooleanField(1, value);
+ }
+
+ public final boolean getIsFailedNoTracking() {
+ return _getBooleanField(2);
+ }
+ public final void setIsFailedNoTracking(boolean value) {
+ _setBooleanField(2, value);
+ }
+
+ public final boolean getIsInitialized() {
+ return _getBooleanField(3);
+ }
+ public final void setIsInitialized(boolean value) {
+ _setBooleanField(3, value);
+ }
+
+ public final boolean getIsInErrorState() {
+ return _getBooleanField(4);
+ }
+ public final void setIsInErrorState(boolean value) {
+ _setBooleanField(4, value);
+ }
+
+ public final boolean getIsLinked() {
+ return _getBooleanField(5);
+ }
+ public final void setIsLinked(boolean value) {
+ _setBooleanField(5, value);
+ }
+
+ public final boolean getHasInitializer() {
+ return _getBooleanField(6);
+ }
+ public final void setHasInitializer(boolean value) {
+ _setBooleanField(6, value);
+ }
+
+ public final boolean getIsBuildTimeInitialized() {
+ return _getBooleanField(7);
+ }
+ public final void setIsBuildTimeInitialized(boolean value) {
+ _setBooleanField(7, value);
+ }
+
+ public final boolean getIsTracked() {
+ return _getBooleanField(8);
+ }
+ public final void setIsTracked(boolean value) {
+ _setBooleanField(8, value);
+ }
+
+ public final int getInitializerMethodId() {
+ return _getIntField(1);
+ }
+ public final void setInitializerMethodId(int value) {
+ _setIntField(1, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean getIsNoInitializerNoTracking() {
+ return _getBooleanField(0);
+ }
+
+ public final boolean getIsInitializedNoTracking() {
+ return _getBooleanField(1);
+ }
+
+ public final boolean getIsFailedNoTracking() {
+ return _getBooleanField(2);
+ }
+
+ public final boolean getIsInitialized() {
+ return _getBooleanField(3);
+ }
+
+ public final boolean getIsInErrorState() {
+ return _getBooleanField(4);
+ }
+
+ public final boolean getIsLinked() {
+ return _getBooleanField(5);
+ }
+
+ public final boolean getHasInitializer() {
+ return _getBooleanField(6);
+ }
+
+ public final boolean getIsBuildTimeInitialized() {
+ return _getBooleanField(7);
+ }
+
+ public final boolean getIsTracked() {
+ return _getBooleanField(8);
+ }
+
+ public final int getInitializerMethodId() {
+ return _getIntField(1);
+ }
+
+ }
+
+ }
+
+
+ public static class PersistedAnalysisMethod {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getId() {
+ return _getIntField(0);
+ }
+ public final void setId(int value) {
+ _setIntField(0, value);
+ }
+
+ public final boolean hasDescriptor() {
+ return !_pointerFieldIsNull(0);
+ }
+ public final org.capnproto.Text.Builder getDescriptor() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+ public final void setDescriptor(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 0, value);
+ }
+ public final void setDescriptor(String value) {
+ _setPointerField(org.capnproto.Text.factory, 0, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initDescriptor(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 0, size);
+ }
+ public final boolean hasName() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.Text.Builder getName() {
+ return _getPointerField(org.capnproto.Text.factory, 1, null, 0, 0);
+ }
+ public final void setName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 1, value);
+ }
+ public final void setName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 1, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 1, size);
+ }
+ public final boolean hasClassName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public final org.capnproto.Text.Builder getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+ public final void setClassName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 2, value);
+ }
+ public final void setClassName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 2, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initClassName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 2, size);
+ }
+ public final int getDeclaringTypeId() {
+ return _getIntField(1);
+ }
+ public final void setDeclaringTypeId(int value) {
+ _setIntField(1, value);
+ }
+
+ public final boolean hasArgumentClassNames() {
+ return !_pointerFieldIsNull(3);
+ }
+ public final org.capnproto.TextList.Builder getArgumentClassNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 3, null, 0);
+ }
+ public final void setArgumentClassNames(org.capnproto.TextList.Reader value) {
+ _setPointerField(org.capnproto.TextList.factory, 3, value);
+ }
+ public final org.capnproto.TextList.Builder initArgumentClassNames(int size) {
+ return _initPointerField(org.capnproto.TextList.factory, 3, size);
+ }
+ public final boolean hasArgumentTypeIds() {
+ return !_pointerFieldIsNull(4);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder getArgumentTypeIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 4, null, 0);
+ }
+ public final void setArgumentTypeIds(org.capnproto.PrimitiveList.Int.Reader value) {
+ _setPointerField(org.capnproto.PrimitiveList.Int.factory, 4, value);
+ }
+ public final org.capnproto.PrimitiveList.Int.Builder initArgumentTypeIds(int size) {
+ return _initPointerField(org.capnproto.PrimitiveList.Int.factory, 4, size);
+ }
+ public final int getReturnTypeId() {
+ return _getIntField(2);
+ }
+ public final void setReturnTypeId(int value) {
+ _setIntField(2, value);
+ }
+
+ public final int getModifiers() {
+ return _getIntField(3);
+ }
+ public final void setModifiers(int value) {
+ _setIntField(3, value);
+ }
+
+ public final boolean hasCode() {
+ return !_pointerFieldIsNull(5);
+ }
+ public final org.capnproto.Data.Builder getCode() {
+ return _getPointerField(org.capnproto.Data.factory, 5, null, 0, 0);
+ }
+ public final void setCode(org.capnproto.Data.Reader value) {
+ _setPointerField(org.capnproto.Data.factory, 5, value);
+ }
+ public final void setCode(byte [] value) {
+ _setPointerField(org.capnproto.Data.factory, 5, new org.capnproto.Data.Reader(value));
+ }
+ public final org.capnproto.Data.Builder initCode(int size) {
+ return _initPointerField(org.capnproto.Data.factory, 5, size);
+ }
+ public final int getCodeSize() {
+ return _getIntField(4);
+ }
+ public final void setCodeSize(int value) {
+ _setIntField(4, value);
+ }
+
+ public final boolean getIsConstructor() {
+ return _getBooleanField(160);
+ }
+ public final void setIsConstructor(boolean value) {
+ _setBooleanField(160, value);
+ }
+
+ public final boolean getIsSynthetic() {
+ return _getBooleanField(161);
+ }
+ public final void setIsSynthetic(boolean value) {
+ _setBooleanField(161, value);
+ }
+
+ public final boolean getCanBeStaticallyBound() {
+ return _getBooleanField(162);
+ }
+ public final void setCanBeStaticallyBound(boolean value) {
+ _setBooleanField(162, value);
+ }
+
+ public final boolean getIsVirtualRootMethod() {
+ return _getBooleanField(163);
+ }
+ public final void setIsVirtualRootMethod(boolean value) {
+ _setBooleanField(163, value);
+ }
+
+ public final boolean getIsDirectRootMethod() {
+ return _getBooleanField(164);
+ }
+ public final void setIsDirectRootMethod(boolean value) {
+ _setBooleanField(164, value);
+ }
+
+ public final boolean getIsInvoked() {
+ return _getBooleanField(165);
+ }
+ public final void setIsInvoked(boolean value) {
+ _setBooleanField(165, value);
+ }
+
+ public final boolean getIsImplementationInvoked() {
+ return _getBooleanField(166);
+ }
+ public final void setIsImplementationInvoked(boolean value) {
+ _setBooleanField(166, value);
+ }
+
+ public final boolean getIsIntrinsicMethod() {
+ return _getBooleanField(167);
+ }
+ public final void setIsIntrinsicMethod(boolean value) {
+ _setBooleanField(167, value);
+ }
+
+ public final boolean hasMethodHandleIntrinsicName() {
+ return !_pointerFieldIsNull(6);
+ }
+ public final org.capnproto.Text.Builder getMethodHandleIntrinsicName() {
+ return _getPointerField(org.capnproto.Text.factory, 6, null, 0, 0);
+ }
+ public final void setMethodHandleIntrinsicName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 6, value);
+ }
+ public final void setMethodHandleIntrinsicName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 6, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initMethodHandleIntrinsicName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 6, size);
+ }
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(7);
+ }
+ public final org.capnproto.StructList.Builder getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 7, null, 0);
+ }
+ public final void setAnnotationList(org.capnproto.StructList.Reader value) {
+ _setPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 7, value);
+ }
+ public final org.capnproto.StructList.Builder initAnnotationList(int size) {
+ return _initPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 7, size);
+ }
+ public final boolean getIsVarArgs() {
+ return _getBooleanField(168);
+ }
+ public final void setIsVarArgs(boolean value) {
+ _setBooleanField(168, value);
+ }
+
+ public final boolean hasAnalysisGraphLocation() {
+ return !_pointerFieldIsNull(8);
+ }
+ public final org.capnproto.Text.Builder getAnalysisGraphLocation() {
+ return _getPointerField(org.capnproto.Text.factory, 8, null, 0, 0);
+ }
+ public final void setAnalysisGraphLocation(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 8, value);
+ }
+ public final void setAnalysisGraphLocation(String value) {
+ _setPointerField(org.capnproto.Text.factory, 8, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initAnalysisGraphLocation(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 8, size);
+ }
+ public final boolean getAnalysisGraphIsIntrinsic() {
+ return _getBooleanField(169);
+ }
+ public final void setAnalysisGraphIsIntrinsic(boolean value) {
+ _setBooleanField(169, value);
+ }
+
+ public final boolean hasStrengthenedGraphLocation() {
+ return !_pointerFieldIsNull(9);
+ }
+ public final org.capnproto.Text.Builder getStrengthenedGraphLocation() {
+ return _getPointerField(org.capnproto.Text.factory, 9, null, 0, 0);
+ }
+ public final void setStrengthenedGraphLocation(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 9, value);
+ }
+ public final void setStrengthenedGraphLocation(String value) {
+ _setPointerField(org.capnproto.Text.factory, 9, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initStrengthenedGraphLocation(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 9, size);
+ }
+ public final WrappedMethod.Builder getWrappedMethod() {
+ return new PersistedAnalysisMethod.WrappedMethod.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final WrappedMethod.Builder initWrappedMethod() {
+ _setShortField(11,(short)0);
+ _setIntField(6,0);
+ _setBooleanField(224,false);
+ _setIntField(8,0);
+ _clearPointerField(10);
+ _clearPointerField(11);
+ _clearPointerField(12);
+ return new PersistedAnalysisMethod.WrappedMethod.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getId() {
+ return _getIntField(0);
+ }
+
+ public boolean hasDescriptor() {
+ return !_pointerFieldIsNull(0);
+ }
+ public org.capnproto.Text.Reader getDescriptor() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+
+ public boolean hasName() {
+ return !_pointerFieldIsNull(1);
+ }
+ public org.capnproto.Text.Reader getName() {
+ return _getPointerField(org.capnproto.Text.factory, 1, null, 0, 0);
+ }
+
+ public boolean hasClassName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public org.capnproto.Text.Reader getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+
+ public final int getDeclaringTypeId() {
+ return _getIntField(1);
+ }
+
+ public final boolean hasArgumentClassNames() {
+ return !_pointerFieldIsNull(3);
+ }
+ public final org.capnproto.TextList.Reader getArgumentClassNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 3, null, 0);
+ }
+
+ public final boolean hasArgumentTypeIds() {
+ return !_pointerFieldIsNull(4);
+ }
+ public final org.capnproto.PrimitiveList.Int.Reader getArgumentTypeIds() {
+ return _getPointerField(org.capnproto.PrimitiveList.Int.factory, 4, null, 0);
+ }
+
+ public final int getReturnTypeId() {
+ return _getIntField(2);
+ }
+
+ public final int getModifiers() {
+ return _getIntField(3);
+ }
+
+ public boolean hasCode() {
+ return !_pointerFieldIsNull(5);
+ }
+ public org.capnproto.Data.Reader getCode() {
+ return _getPointerField(org.capnproto.Data.factory, 5, null, 0, 0);
+ }
+
+ public final int getCodeSize() {
+ return _getIntField(4);
+ }
+
+ public final boolean getIsConstructor() {
+ return _getBooleanField(160);
+ }
+
+ public final boolean getIsSynthetic() {
+ return _getBooleanField(161);
+ }
+
+ public final boolean getCanBeStaticallyBound() {
+ return _getBooleanField(162);
+ }
+
+ public final boolean getIsVirtualRootMethod() {
+ return _getBooleanField(163);
+ }
+
+ public final boolean getIsDirectRootMethod() {
+ return _getBooleanField(164);
+ }
+
+ public final boolean getIsInvoked() {
+ return _getBooleanField(165);
+ }
+
+ public final boolean getIsImplementationInvoked() {
+ return _getBooleanField(166);
+ }
+
+ public final boolean getIsIntrinsicMethod() {
+ return _getBooleanField(167);
+ }
+
+ public boolean hasMethodHandleIntrinsicName() {
+ return !_pointerFieldIsNull(6);
+ }
+ public org.capnproto.Text.Reader getMethodHandleIntrinsicName() {
+ return _getPointerField(org.capnproto.Text.factory, 6, null, 0, 0);
+ }
+
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(7);
+ }
+ public final org.capnproto.StructList.Reader getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 7, null, 0);
+ }
+
+ public final boolean getIsVarArgs() {
+ return _getBooleanField(168);
+ }
+
+ public boolean hasAnalysisGraphLocation() {
+ return !_pointerFieldIsNull(8);
+ }
+ public org.capnproto.Text.Reader getAnalysisGraphLocation() {
+ return _getPointerField(org.capnproto.Text.factory, 8, null, 0, 0);
+ }
+
+ public final boolean getAnalysisGraphIsIntrinsic() {
+ return _getBooleanField(169);
+ }
+
+ public boolean hasStrengthenedGraphLocation() {
+ return !_pointerFieldIsNull(9);
+ }
+ public org.capnproto.Text.Reader getStrengthenedGraphLocation() {
+ return _getPointerField(org.capnproto.Text.factory, 9, null, 0, 0);
+ }
+
+ public WrappedMethod.Reader getWrappedMethod() {
+ return new PersistedAnalysisMethod.WrappedMethod.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ }
+
+ public static class WrappedMethod {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.WrappedMethod.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public Which which() {
+ switch(_getShortField(11)) {
+ case 0 : return Which.NONE;
+ case 1 : return Which.FACTORY_METHOD;
+ case 2 : return Which.OUTLINED_S_B;
+ case 3 : return Which.C_ENTRY_POINT_CALL_STUB;
+ case 4 : return Which.WRAPPED_MEMBER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean isNone() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.NONE;
+ }
+ public final org.capnproto.Void getNone() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.Which.NONE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setNone(org.capnproto.Void value) {
+ _setShortField(11, (short)PersistedAnalysisMethod.WrappedMethod.Which.NONE.ordinal());
+ }
+
+ public final boolean isFactoryMethod() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.FACTORY_METHOD;
+ }
+ public final FactoryMethod.Builder getFactoryMethod() {
+ return new PersistedAnalysisMethod.WrappedMethod.FactoryMethod.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final FactoryMethod.Builder initFactoryMethod() {
+ _setShortField(11, (short)PersistedAnalysisMethod.WrappedMethod.Which.FACTORY_METHOD.ordinal());
+ _setIntField(6,0);
+ _setBooleanField(224,false);
+ _setIntField(8,0);
+ return new PersistedAnalysisMethod.WrappedMethod.FactoryMethod.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isOutlinedSB() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.OUTLINED_S_B;
+ }
+ public final OutlinedSB.Builder getOutlinedSB() {
+ return new PersistedAnalysisMethod.WrappedMethod.OutlinedSB.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final OutlinedSB.Builder initOutlinedSB() {
+ _setShortField(11, (short)PersistedAnalysisMethod.WrappedMethod.Which.OUTLINED_S_B.ordinal());
+ _clearPointerField(10);
+ _clearPointerField(11);
+ return new PersistedAnalysisMethod.WrappedMethod.OutlinedSB.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isCEntryPointCallStub() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.C_ENTRY_POINT_CALL_STUB;
+ }
+ public final CEntryPointCallStub.Builder getCEntryPointCallStub() {
+ return new PersistedAnalysisMethod.WrappedMethod.CEntryPointCallStub.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final CEntryPointCallStub.Builder initCEntryPointCallStub() {
+ _setShortField(11, (short)PersistedAnalysisMethod.WrappedMethod.Which.C_ENTRY_POINT_CALL_STUB.ordinal());
+ _setBooleanField(192,false);
+ _setIntField(8,0);
+ return new PersistedAnalysisMethod.WrappedMethod.CEntryPointCallStub.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isWrappedMember() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.WRAPPED_MEMBER;
+ }
+ public final WrappedMember.Builder getWrappedMember() {
+ return new PersistedAnalysisMethod.WrappedMethod.WrappedMember.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final WrappedMember.Builder initWrappedMember() {
+ _setShortField(11, (short)PersistedAnalysisMethod.WrappedMethod.Which.WRAPPED_MEMBER.ordinal());
+ _setShortField(16,(short)0);
+ _clearPointerField(10);
+ _clearPointerField(11);
+ _clearPointerField(12);
+ return new PersistedAnalysisMethod.WrappedMethod.WrappedMember.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public Which which() {
+ switch(_getShortField(11)) {
+ case 0 : return Which.NONE;
+ case 1 : return Which.FACTORY_METHOD;
+ case 2 : return Which.OUTLINED_S_B;
+ case 3 : return Which.C_ENTRY_POINT_CALL_STUB;
+ case 4 : return Which.WRAPPED_MEMBER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final boolean isNone() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.NONE;
+ }
+ public final org.capnproto.Void getNone() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.Which.NONE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public final boolean isFactoryMethod() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.FACTORY_METHOD;
+ }
+ public FactoryMethod.Reader getFactoryMethod() {
+ return new PersistedAnalysisMethod.WrappedMethod.FactoryMethod.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isOutlinedSB() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.OUTLINED_S_B;
+ }
+ public OutlinedSB.Reader getOutlinedSB() {
+ return new PersistedAnalysisMethod.WrappedMethod.OutlinedSB.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isCEntryPointCallStub() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.C_ENTRY_POINT_CALL_STUB;
+ }
+ public CEntryPointCallStub.Reader getCEntryPointCallStub() {
+ return new PersistedAnalysisMethod.WrappedMethod.CEntryPointCallStub.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isWrappedMember() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.Which.WRAPPED_MEMBER;
+ }
+ public WrappedMember.Reader getWrappedMember() {
+ return new PersistedAnalysisMethod.WrappedMethod.WrappedMember.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ }
+
+ public enum Which {
+ NONE,
+ FACTORY_METHOD,
+ OUTLINED_S_B,
+ C_ENTRY_POINT_CALL_STUB,
+ WRAPPED_MEMBER,
+ _NOT_IN_SCHEMA,
+ }
+ public static class FactoryMethod {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.WrappedMethod.FactoryMethod.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getTargetConstructorId() {
+ return _getIntField(6);
+ }
+ public final void setTargetConstructorId(int value) {
+ _setIntField(6, value);
+ }
+
+ public final boolean getThrowAllocatedObject() {
+ return _getBooleanField(224);
+ }
+ public final void setThrowAllocatedObject(boolean value) {
+ _setBooleanField(224, value);
+ }
+
+ public final int getInstantiatedTypeId() {
+ return _getIntField(8);
+ }
+ public final void setInstantiatedTypeId(int value) {
+ _setIntField(8, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getTargetConstructorId() {
+ return _getIntField(6);
+ }
+
+ public final boolean getThrowAllocatedObject() {
+ return _getBooleanField(224);
+ }
+
+ public final int getInstantiatedTypeId() {
+ return _getIntField(8);
+ }
+
+ }
+
+ }
+
+
+ public static class OutlinedSB {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.WrappedMethod.OutlinedSB.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean hasMethodTypeReturn() {
+ return !_pointerFieldIsNull(10);
+ }
+ public final org.capnproto.Text.Builder getMethodTypeReturn() {
+ return _getPointerField(org.capnproto.Text.factory, 10, null, 0, 0);
+ }
+ public final void setMethodTypeReturn(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 10, value);
+ }
+ public final void setMethodTypeReturn(String value) {
+ _setPointerField(org.capnproto.Text.factory, 10, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initMethodTypeReturn(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 10, size);
+ }
+ public final boolean hasMethodTypeParameters() {
+ return !_pointerFieldIsNull(11);
+ }
+ public final org.capnproto.TextList.Builder getMethodTypeParameters() {
+ return _getPointerField(org.capnproto.TextList.factory, 11, null, 0);
+ }
+ public final void setMethodTypeParameters(org.capnproto.TextList.Reader value) {
+ _setPointerField(org.capnproto.TextList.factory, 11, value);
+ }
+ public final org.capnproto.TextList.Builder initMethodTypeParameters(int size) {
+ return _initPointerField(org.capnproto.TextList.factory, 11, size);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public boolean hasMethodTypeReturn() {
+ return !_pointerFieldIsNull(10);
+ }
+ public org.capnproto.Text.Reader getMethodTypeReturn() {
+ return _getPointerField(org.capnproto.Text.factory, 10, null, 0, 0);
+ }
+
+ public final boolean hasMethodTypeParameters() {
+ return !_pointerFieldIsNull(11);
+ }
+ public final org.capnproto.TextList.Reader getMethodTypeParameters() {
+ return _getPointerField(org.capnproto.TextList.factory, 11, null, 0);
+ }
+
+ }
+
+ }
+
+
+ public static class CEntryPointCallStub {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.WrappedMethod.CEntryPointCallStub.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getOriginalMethodId() {
+ return _getIntField(8);
+ }
+ public final void setOriginalMethodId(int value) {
+ _setIntField(8, value);
+ }
+
+ public final boolean getNotPublished() {
+ return _getBooleanField(192);
+ }
+ public final void setNotPublished(boolean value) {
+ _setBooleanField(192, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getOriginalMethodId() {
+ return _getIntField(8);
+ }
+
+ public final boolean getNotPublished() {
+ return _getBooleanField(192);
+ }
+
+ }
+
+ }
+
+
+ public static class WrappedMember {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)5,(short)13);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisMethod.WrappedMethod.WrappedMember.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public Which which() {
+ switch(_getShortField(16)) {
+ case 0 : return Which.REFLECTION_EXPAND_SIGNATURE;
+ case 1 : return Which.JAVA_CALL_VARIANT_WRAPPER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean isReflectionExpandSignature() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.REFLECTION_EXPAND_SIGNATURE;
+ }
+ public final org.capnproto.Void getReflectionExpandSignature() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.REFLECTION_EXPAND_SIGNATURE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setReflectionExpandSignature(org.capnproto.Void value) {
+ _setShortField(16, (short)PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.REFLECTION_EXPAND_SIGNATURE.ordinal());
+ }
+
+ public final boolean isJavaCallVariantWrapper() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.JAVA_CALL_VARIANT_WRAPPER;
+ }
+ public final org.capnproto.Void getJavaCallVariantWrapper() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.JAVA_CALL_VARIANT_WRAPPER:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setJavaCallVariantWrapper(org.capnproto.Void value) {
+ _setShortField(16, (short)PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.JAVA_CALL_VARIANT_WRAPPER.ordinal());
+ }
+
+ public final boolean hasName() {
+ return !_pointerFieldIsNull(10);
+ }
+ public final org.capnproto.Text.Builder getName() {
+ return _getPointerField(org.capnproto.Text.factory, 10, null, 0, 0);
+ }
+ public final void setName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 10, value);
+ }
+ public final void setName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 10, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 10, size);
+ }
+ public final boolean hasDeclaringClassName() {
+ return !_pointerFieldIsNull(11);
+ }
+ public final org.capnproto.Text.Builder getDeclaringClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+ public final void setDeclaringClassName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 11, value);
+ }
+ public final void setDeclaringClassName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 11, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initDeclaringClassName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 11, size);
+ }
+ public final boolean hasArgumentTypeNames() {
+ return !_pointerFieldIsNull(12);
+ }
+ public final org.capnproto.TextList.Builder getArgumentTypeNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 12, null, 0);
+ }
+ public final void setArgumentTypeNames(org.capnproto.TextList.Reader value) {
+ _setPointerField(org.capnproto.TextList.factory, 12, value);
+ }
+ public final org.capnproto.TextList.Builder initArgumentTypeNames(int size) {
+ return _initPointerField(org.capnproto.TextList.factory, 12, size);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public Which which() {
+ switch(_getShortField(16)) {
+ case 0 : return Which.REFLECTION_EXPAND_SIGNATURE;
+ case 1 : return Which.JAVA_CALL_VARIANT_WRAPPER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final boolean isReflectionExpandSignature() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.REFLECTION_EXPAND_SIGNATURE;
+ }
+ public final org.capnproto.Void getReflectionExpandSignature() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.REFLECTION_EXPAND_SIGNATURE:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public final boolean isJavaCallVariantWrapper() {
+ return which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.JAVA_CALL_VARIANT_WRAPPER;
+ }
+ public final org.capnproto.Void getJavaCallVariantWrapper() {
+ assert which() == PersistedAnalysisMethod.WrappedMethod.WrappedMember.Which.JAVA_CALL_VARIANT_WRAPPER:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public boolean hasName() {
+ return !_pointerFieldIsNull(10);
+ }
+ public org.capnproto.Text.Reader getName() {
+ return _getPointerField(org.capnproto.Text.factory, 10, null, 0, 0);
+ }
+
+ public boolean hasDeclaringClassName() {
+ return !_pointerFieldIsNull(11);
+ }
+ public org.capnproto.Text.Reader getDeclaringClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 11, null, 0, 0);
+ }
+
+ public final boolean hasArgumentTypeNames() {
+ return !_pointerFieldIsNull(12);
+ }
+ public final org.capnproto.TextList.Reader getArgumentTypeNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 12, null, 0);
+ }
+
+ }
+
+ public enum Which {
+ REFLECTION_EXPAND_SIGNATURE,
+ JAVA_CALL_VARIANT_WRAPPER,
+ _NOT_IN_SCHEMA,
+ }
+ }
+
+
+ }
+
+
+ }
+
+
+ public static class PersistedAnalysisField {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)4,(short)3);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return PersistedAnalysisField.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getId() {
+ return _getIntField(0);
+ }
+ public final void setId(int value) {
+ _setIntField(0, value);
+ }
+
+ public final boolean hasClassName() {
+ return !_pointerFieldIsNull(0);
+ }
+ public final org.capnproto.Text.Builder getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+ public final void setClassName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 0, value);
+ }
+ public final void setClassName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 0, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initClassName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 0, size);
+ }
+ public final int getDeclaringTypeId() {
+ return _getIntField(1);
+ }
+ public final void setDeclaringTypeId(int value) {
+ _setIntField(1, value);
+ }
+
+ public final int getTypeId() {
+ return _getIntField(2);
+ }
+ public final void setTypeId(int value) {
+ _setIntField(2, value);
+ }
+
+ public final int getPosition() {
+ return _getIntField(3);
+ }
+ public final void setPosition(int value) {
+ _setIntField(3, value);
+ }
+
+ public final int getLocation() {
+ return _getIntField(4);
+ }
+ public final void setLocation(int value) {
+ _setIntField(4, value);
+ }
+
+ public final int getModifiers() {
+ return _getIntField(5);
+ }
+ public final void setModifiers(int value) {
+ _setIntField(5, value);
+ }
+
+ public final boolean getIsInternal() {
+ return _getBooleanField(192);
+ }
+ public final void setIsInternal(boolean value) {
+ _setBooleanField(192, value);
+ }
+
+ public final boolean getIsAccessed() {
+ return _getBooleanField(193);
+ }
+ public final void setIsAccessed(boolean value) {
+ _setBooleanField(193, value);
+ }
+
+ public final boolean getIsRead() {
+ return _getBooleanField(194);
+ }
+ public final void setIsRead(boolean value) {
+ _setBooleanField(194, value);
+ }
+
+ public final boolean getIsWritten() {
+ return _getBooleanField(195);
+ }
+ public final void setIsWritten(boolean value) {
+ _setBooleanField(195, value);
+ }
+
+ public final boolean getIsFolded() {
+ return _getBooleanField(196);
+ }
+ public final void setIsFolded(boolean value) {
+ _setBooleanField(196, value);
+ }
+
+ public final boolean getIsStatic() {
+ return _getBooleanField(197);
+ }
+ public final void setIsStatic(boolean value) {
+ _setBooleanField(197, value);
+ }
+
+ public final boolean getIsSynthetic() {
+ return _getBooleanField(198);
+ }
+ public final void setIsSynthetic(boolean value) {
+ _setBooleanField(198, value);
+ }
+
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.StructList.Builder getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 1, null, 0);
+ }
+ public final void setAnnotationList(org.capnproto.StructList.Reader value) {
+ _setPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 1, value);
+ }
+ public final org.capnproto.StructList.Builder initAnnotationList(int size) {
+ return _initPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 1, size);
+ }
+ public final boolean hasName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public final org.capnproto.Text.Builder getName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+ public final void setName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 2, value);
+ }
+ public final void setName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 2, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 2, size);
+ }
+ public final int getFieldCheckIndex() {
+ return _getIntField(7);
+ }
+ public final void setFieldCheckIndex(int value) {
+ _setIntField(7, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getId() {
+ return _getIntField(0);
+ }
+
+ public boolean hasClassName() {
+ return !_pointerFieldIsNull(0);
+ }
+ public org.capnproto.Text.Reader getClassName() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+
+ public final int getDeclaringTypeId() {
+ return _getIntField(1);
+ }
+
+ public final int getTypeId() {
+ return _getIntField(2);
+ }
+
+ public final int getPosition() {
+ return _getIntField(3);
+ }
+
+ public final int getLocation() {
+ return _getIntField(4);
+ }
+
+ public final int getModifiers() {
+ return _getIntField(5);
+ }
+
+ public final boolean getIsInternal() {
+ return _getBooleanField(192);
+ }
+
+ public final boolean getIsAccessed() {
+ return _getBooleanField(193);
+ }
+
+ public final boolean getIsRead() {
+ return _getBooleanField(194);
+ }
+
+ public final boolean getIsWritten() {
+ return _getBooleanField(195);
+ }
+
+ public final boolean getIsFolded() {
+ return _getBooleanField(196);
+ }
+
+ public final boolean getIsStatic() {
+ return _getBooleanField(197);
+ }
+
+ public final boolean getIsSynthetic() {
+ return _getBooleanField(198);
+ }
+
+ public final boolean hasAnnotationList() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.StructList.Reader getAnnotationList() {
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.Annotation.listFactory, 1, null, 0);
+ }
+
+ public boolean hasName() {
+ return !_pointerFieldIsNull(2);
+ }
+ public org.capnproto.Text.Reader getName() {
+ return _getPointerField(org.capnproto.Text.factory, 2, null, 0, 0);
+ }
+
+ public final int getFieldCheckIndex() {
+ return _getIntField(7);
+ }
+
+ }
+
+ }
+
+
+ public static class CEntryPointLiteralReference {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)0,(short)3);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return CEntryPointLiteralReference.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean hasMethodName() {
+ return !_pointerFieldIsNull(0);
+ }
+ public final org.capnproto.Text.Builder getMethodName() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+ public final void setMethodName(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 0, value);
+ }
+ public final void setMethodName(String value) {
+ _setPointerField(org.capnproto.Text.factory, 0, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initMethodName(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 0, size);
+ }
+ public final boolean hasDefiningClass() {
+ return !_pointerFieldIsNull(1);
+ }
+ public final org.capnproto.Text.Builder getDefiningClass() {
+ return _getPointerField(org.capnproto.Text.factory, 1, null, 0, 0);
+ }
+ public final void setDefiningClass(org.capnproto.Text.Reader value) {
+ _setPointerField(org.capnproto.Text.factory, 1, value);
+ }
+ public final void setDefiningClass(String value) {
+ _setPointerField(org.capnproto.Text.factory, 1, new org.capnproto.Text.Reader(value));
+ }
+ public final org.capnproto.Text.Builder initDefiningClass(int size) {
+ return _initPointerField(org.capnproto.Text.factory, 1, size);
+ }
+ public final boolean hasParameterNames() {
+ return !_pointerFieldIsNull(2);
+ }
+ public final org.capnproto.TextList.Builder getParameterNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 2, null, 0);
+ }
+ public final void setParameterNames(org.capnproto.TextList.Reader value) {
+ _setPointerField(org.capnproto.TextList.factory, 2, value);
+ }
+ public final org.capnproto.TextList.Builder initParameterNames(int size) {
+ return _initPointerField(org.capnproto.TextList.factory, 2, size);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public boolean hasMethodName() {
+ return !_pointerFieldIsNull(0);
+ }
+ public org.capnproto.Text.Reader getMethodName() {
+ return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0);
+ }
+
+ public boolean hasDefiningClass() {
+ return !_pointerFieldIsNull(1);
+ }
+ public org.capnproto.Text.Reader getDefiningClass() {
+ return _getPointerField(org.capnproto.Text.factory, 1, null, 0, 0);
+ }
+
+ public final boolean hasParameterNames() {
+ return !_pointerFieldIsNull(2);
+ }
+ public final org.capnproto.TextList.Reader getParameterNames() {
+ return _getPointerField(org.capnproto.TextList.factory, 2, null, 0);
+ }
+
+ }
+
+ }
+
+
+ public static class ConstantReference {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)2,(short)1);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return ConstantReference.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public Which which() {
+ switch(_getShortField(2)) {
+ case 0 : return Which.OBJECT_CONSTANT;
+ case 1 : return Which.NULL_POINTER;
+ case 2 : return Which.NOT_MATERIALIZED;
+ case 3 : return Which.PRIMITIVE_VALUE;
+ case 4 : return Which.METHOD_POINTER;
+ case 5 : return Which.C_ENTRY_POINT_LITERAL_CODE_POINTER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final boolean isObjectConstant() {
+ return which() == ConstantReference.Which.OBJECT_CONSTANT;
+ }
+ public final ObjectConstant.Builder getObjectConstant() {
+ return new ConstantReference.ObjectConstant.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final ObjectConstant.Builder initObjectConstant() {
+ _setShortField(2, (short)ConstantReference.Which.OBJECT_CONSTANT.ordinal());
+ _setIntField(0,0);
+ return new ConstantReference.ObjectConstant.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isNullPointer() {
+ return which() == ConstantReference.Which.NULL_POINTER;
+ }
+ public final org.capnproto.Void getNullPointer() {
+ assert which() == ConstantReference.Which.NULL_POINTER:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setNullPointer(org.capnproto.Void value) {
+ _setShortField(2, (short)ConstantReference.Which.NULL_POINTER.ordinal());
+ }
+
+ public final boolean isNotMaterialized() {
+ return which() == ConstantReference.Which.NOT_MATERIALIZED;
+ }
+ public final org.capnproto.Void getNotMaterialized() {
+ assert which() == ConstantReference.Which.NOT_MATERIALIZED:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+ public final void setNotMaterialized(org.capnproto.Void value) {
+ _setShortField(2, (short)ConstantReference.Which.NOT_MATERIALIZED.ordinal());
+ }
+
+ public final boolean isPrimitiveValue() {
+ return which() == ConstantReference.Which.PRIMITIVE_VALUE;
+ }
+ public final PrimitiveValue.Builder getPrimitiveValue() {
+ return new ConstantReference.PrimitiveValue.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final PrimitiveValue.Builder initPrimitiveValue() {
+ _setShortField(2, (short)ConstantReference.Which.PRIMITIVE_VALUE.ordinal());
+ _setByteField(0,(byte)0);
+ _setLongField(1,0L);
+ return new ConstantReference.PrimitiveValue.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isMethodPointer() {
+ return which() == ConstantReference.Which.METHOD_POINTER;
+ }
+ public final MethodPointer.Builder getMethodPointer() {
+ return new ConstantReference.MethodPointer.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final MethodPointer.Builder initMethodPointer() {
+ _setShortField(2, (short)ConstantReference.Which.METHOD_POINTER.ordinal());
+ _setIntField(0,0);
+ return new ConstantReference.MethodPointer.Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+
+ public final boolean isCEntryPointLiteralCodePointer() {
+ return which() == ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER;
+ }
+ public final com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.Builder getCEntryPointLiteralCodePointer() {
+ assert which() == ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER:
+ "Must check which() before get()ing a union member.";
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.factory, 0, null, 0);
+ }
+ public final void setCEntryPointLiteralCodePointer(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.Reader value) {
+ _setShortField(2, (short)ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER.ordinal());
+ _setPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.factory,0, value);
+ }
+ public final com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.Builder initCEntryPointLiteralCodePointer() {
+ _setShortField(2, (short)ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER.ordinal());
+ return _initPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.factory,0, 0);
+ }
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public Which which() {
+ switch(_getShortField(2)) {
+ case 0 : return Which.OBJECT_CONSTANT;
+ case 1 : return Which.NULL_POINTER;
+ case 2 : return Which.NOT_MATERIALIZED;
+ case 3 : return Which.PRIMITIVE_VALUE;
+ case 4 : return Which.METHOD_POINTER;
+ case 5 : return Which.C_ENTRY_POINT_LITERAL_CODE_POINTER;
+ default: return Which._NOT_IN_SCHEMA;
+ }
+ }
+ public final boolean isObjectConstant() {
+ return which() == ConstantReference.Which.OBJECT_CONSTANT;
+ }
+ public ObjectConstant.Reader getObjectConstant() {
+ return new ConstantReference.ObjectConstant.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isNullPointer() {
+ return which() == ConstantReference.Which.NULL_POINTER;
+ }
+ public final org.capnproto.Void getNullPointer() {
+ assert which() == ConstantReference.Which.NULL_POINTER:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public final boolean isNotMaterialized() {
+ return which() == ConstantReference.Which.NOT_MATERIALIZED;
+ }
+ public final org.capnproto.Void getNotMaterialized() {
+ assert which() == ConstantReference.Which.NOT_MATERIALIZED:
+ "Must check which() before get()ing a union member.";
+ return org.capnproto.Void.VOID;
+ }
+
+ public final boolean isPrimitiveValue() {
+ return which() == ConstantReference.Which.PRIMITIVE_VALUE;
+ }
+ public PrimitiveValue.Reader getPrimitiveValue() {
+ return new ConstantReference.PrimitiveValue.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isMethodPointer() {
+ return which() == ConstantReference.Which.METHOD_POINTER;
+ }
+ public MethodPointer.Reader getMethodPointer() {
+ return new ConstantReference.MethodPointer.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final boolean isCEntryPointLiteralCodePointer() {
+ return which() == ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER;
+ }
+ public boolean hasCEntryPointLiteralCodePointer() {
+ return !_pointerFieldIsNull(0);
+ }
+ public com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.Reader getCEntryPointLiteralCodePointer() {
+ assert which() == ConstantReference.Which.C_ENTRY_POINT_LITERAL_CODE_POINTER:
+ "Must check which() before get()ing a union member.";
+ return _getPointerField(com.oracle.graal.pointsto.heap.SharedLayerSnapshotCapnProtoSchemaHolder.CEntryPointLiteralReference.factory,0,null, 0);
+ }
+
+ }
+
+ public enum Which {
+ OBJECT_CONSTANT,
+ NULL_POINTER,
+ NOT_MATERIALIZED,
+ PRIMITIVE_VALUE,
+ METHOD_POINTER,
+ C_ENTRY_POINT_LITERAL_CODE_POINTER,
+ _NOT_IN_SCHEMA,
+ }
+ public static class ObjectConstant {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)2,(short)1);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return ConstantReference.ObjectConstant.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final int getConstantId() {
+ return _getIntField(0);
+ }
+ public final void setConstantId(int value) {
+ _setIntField(0, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final int getConstantId() {
+ return _getIntField(0);
+ }
+
+ }
+
+ }
+
+
+ public static class PrimitiveValue {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)2,(short)1);
+ public static final class Factory extends org.capnproto.StructFactory {
+ public Factory() {
+ }
+ public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) {
+ return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
+ }
+ public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) {
+ return new Builder(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final org.capnproto.StructSize structSize() {
+ return ConstantReference.PrimitiveValue.STRUCT_SIZE;
+ }
+ public final Reader asReader(Builder builder) {
+ return builder.asReader();
+ }
+ }
+ public static final Factory factory = new Factory();
+ public static final org.capnproto.StructList.Factory listFactory =
+ new org.capnproto.StructList.Factory(factory);
+ public static final class Builder extends org.capnproto.StructBuilder {
+ Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){
+ super(segment, data, pointers, dataSize, pointerCount);
+ }
+ public final Reader asReader() {
+ return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);
+ }
+ public final byte getTypeChar() {
+ return _getByteField(0);
+ }
+ public final void setTypeChar(byte value) {
+ _setByteField(0, value);
+ }
+
+ public final long getRawValue() {
+ return _getLongField(1);
+ }
+ public final void setRawValue(long value) {
+ _setLongField(1, value);
+ }
+
+ }
+
+ public static final class Reader extends org.capnproto.StructReader {
+ Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){
+ super(segment, data, pointers, dataSize, pointerCount, nestingLimit);
+ }
+
+ public final byte getTypeChar() {
+ return _getByteField(0);
+ }
+
+ public final long getRawValue() {
+ return _getLongField(1);
+ }
+
+ }
+
+ }
+
+
+ public static class MethodPointer {
+ public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)2,(short)1);
+ public static final class Factory extends org.capnproto.StructFactory