[GR-55502] Add support for calling MultiLayeredImageSingleton.getAllLayers from traditional builds.

PullRequest: graal/18307

Author: teshull

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/code/ImageCodeInfo.java

@@ -41,7 +41,6 @@
 import com.oracle.svm.core.c.NonmovableObjectArray;
 import com.oracle.svm.core.heap.UnknownObjectField;
 import com.oracle.svm.core.heap.UnknownPrimitiveField;
-import com.oracle.svm.core.imagelayer.ImageLayerBuildingSupport;
 import com.oracle.svm.core.layeredimagesingleton.LayeredImageSingletonBuilderFlags;
 import com.oracle.svm.core.layeredimagesingleton.MultiLayeredImageSingleton;
 import com.oracle.svm.core.layeredimagesingleton.UnsavedSingleton;
@@ -87,27 +86,21 @@ public class ImageCodeInfo implements MultiLayeredImageSingleton, UnsavedSinglet
 
     @Uninterruptible(reason = "Executes during isolate creation.")
     CodeInfo prepareCodeInfo() {
-        if (!ImageLayerBuildingSupport.buildingImageLayer()) {
-            ImageCodeInfo imageCodeInfo = CodeInfoTable.getImageCodeCache();
-            CodeInfoImpl codeInfo = ImageCodeInfoStorage.get();
-            return ImageCodeInfo.prepareCodeInfo0(imageCodeInfo, codeInfo, WordFactory.nullPointer());
-        } else {
-            ImageCodeInfo[] imageCodeInfos = MultiLayeredImageSingleton.getAllLayers(ImageCodeInfo.class);
-            ImageCodeInfoStorage[] runtimeCodeInfos = MultiLayeredImageSingleton.getAllLayers(ImageCodeInfoStorage.class);
-            int size = imageCodeInfos.length;
-            for (int i = 0; i < size; i++) {
-                ImageCodeInfo imageCodeInfo = imageCodeInfos[i];
-                CodeInfoImpl codeInfoImpl = runtimeCodeInfos[i].getData();
-                CodeInfoImpl nextCodeInfoImpl = i + 1 < size ? runtimeCodeInfos[i + 1].getData() : WordFactory.nullPointer();
-
-                ImageCodeInfo.prepareCodeInfo0(imageCodeInfo, codeInfoImpl, nextCodeInfoImpl);
-            }
-            return runtimeCodeInfos[0].getData();
+        ImageCodeInfo[] imageCodeInfos = MultiLayeredImageSingleton.getAllLayers(ImageCodeInfo.class);
+        ImageCodeInfoStorage[] runtimeCodeInfos = MultiLayeredImageSingleton.getAllLayers(ImageCodeInfoStorage.class);
+        int size = imageCodeInfos.length;
+        for (int i = 0; i < size; i++) {
+            ImageCodeInfo imageCodeInfo = imageCodeInfos[i];
+            CodeInfoImpl codeInfoImpl = runtimeCodeInfos[i].getData();
+            CodeInfoImpl nextCodeInfoImpl = i + 1 < size ? runtimeCodeInfos[i + 1].getData() : WordFactory.nullPointer();
+
+            ImageCodeInfo.prepareCodeInfo0(imageCodeInfo, codeInfoImpl, nextCodeInfoImpl);
         }
+        return runtimeCodeInfos[0].getData();
     }
 
     @Uninterruptible(reason = "Executes during isolate creation.")
-    private static CodeInfo prepareCodeInfo0(ImageCodeInfo imageCodeInfo, CodeInfoImpl infoImpl, CodeInfo next) {
+    private static void prepareCodeInfo0(ImageCodeInfo imageCodeInfo, CodeInfoImpl infoImpl, CodeInfo next) {
         assert infoImpl.getCodeStart().isNull() : "already initialized";
 
         infoImpl.setObjectFields(NonmovableArrays.fromImageHeap(imageCodeInfo.objectFields));
@@ -128,8 +121,6 @@ private static CodeInfo prepareCodeInfo0(ImageCodeInfo imageCodeInfo, CodeInfoIm
         infoImpl.setMethodTableFirstId(imageCodeInfo.methodTableFirstId);
         infoImpl.setIsAOTImageCode(true);
         infoImpl.setNextImageCodeInfo(next);
-
-        return infoImpl;
     }
 
     /**

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/layeredimagesingleton/ApplicationLayerOnlyImageSingleton.java

@@ -24,5 +24,9 @@
  */
 package com.oracle.svm.core.layeredimagesingleton;
 
+/**
+ * Identifies a singleton for which all lookups refer to a single singleton which will be created in
+ * the application layer. See {@link LayeredImageSingleton} for full explanation.
+ */
 public interface ApplicationLayerOnlyImageSingleton extends LayeredImageSingleton {
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/layeredimagesingleton/LayeredImageSingleton.java

@@ -42,12 +42,18 @@
  * <li>{@link MultiLayeredImageSingleton}: {@link ImageSingletons#lookup} calls continue to refer to
  * the appropriate per layer image singleton, but there is also an additional method
  * {@link MultiLayeredImageSingleton#getAllLayers} which returns an array with the image singletons
- * corresponding to this key in all layers they were created.</li>
+ * corresponding to this key in all layers they were created. The length of this array will vary
+ * from [0, total #layers], based on the number of layers singletons were installed in (i.e., it is
+ * not required for the singleton to be installed in all layers). Within the array, the singletons
+ * will be arranged so that index [0] corresponds to the singleton originating from the oldest layer
+ * in which the singleton was installed and index [length - 1] holds the singleton from the newest
+ * layer.</li>
  * </ul>
  *
- * Note the unique behavior of {@link ApplicationLayerOnlyImageSingleton} and
- * {@link MultiLayeredImageSingleton} apply only when building a layered image. During a traditional
- * build these flags do not have an impact.
+ * Note the unique behavior of {@link ApplicationLayerOnlyImageSingleton} applies only when building
+ * a layered image. Calling {@link MultiLayeredImageSingleton#getAllLayers} during a traditional
+ * build requires the singleton to be installed in the build and will return an array of length 1
+ * containing that singleton.
  *
  * Currently, when using these special singleton types there are additional restrictions:
  *

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/layeredimagesingleton/MultiLayeredImageSingleton.java

@@ -28,6 +28,10 @@
 
 public interface MultiLayeredImageSingleton extends LayeredImageSingleton {
 
+    /**
+     * Returns an array containing the image singletons installed for {@code key} within all layers.
+     * See {@link LayeredImageSingleton} for full explanation.
+     */
     @SuppressWarnings("unused")
     static <T extends MultiLayeredImageSingleton> T[] getAllLayers(Class<T> key) {
         throw VMError.shouldNotReachHere("This can only be called during runtime");

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/layeredimagesingleton/NonLayeredImageSingletonFeature.java

@@ -0,0 +1,87 @@
+/*
+ * 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.
+ */
+package com.oracle.svm.core.layeredimagesingleton;
+
+import java.lang.reflect.Array;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.graalvm.nativeimage.hosted.Feature;
+
+import com.oracle.svm.core.ParsingReason;
+import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
+import com.oracle.svm.core.feature.InternalFeature;
+import com.oracle.svm.core.imagelayer.ImageLayerBuildingSupport;
+import com.oracle.svm.core.util.VMError;
+
+import jdk.graal.compiler.nodes.ConstantNode;
+import jdk.graal.compiler.nodes.ValueNode;
+import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration;
+import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext;
+import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin;
+import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins;
+import jdk.graal.compiler.phases.util.Providers;
+import jdk.vm.ci.meta.JavaKind;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+/**
+ * Adds support for layered image singleton features within traditional builds.
+ */
+@AutomaticallyRegisteredFeature
+public class NonLayeredImageSingletonFeature implements InternalFeature, FeatureSingleton {
+
+    ConcurrentHashMap<Class<?>, Object> multiLayeredArrays = new ConcurrentHashMap<>();
+
+    @Override
+    public boolean isInConfiguration(Feature.IsInConfigurationAccess access) {
+        return !ImageLayerBuildingSupport.buildingImageLayer();
+    }
+
+    @Override
+    public void registerInvocationPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) {
+        InvocationPlugins.Registration r = new InvocationPlugins.Registration(plugins.getInvocationPlugins(), MultiLayeredImageSingleton.class);
+        r.register(new InvocationPlugin.RequiredInvocationPlugin("getAllLayers", Class.class) {
+
+            @Override
+            public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) {
+                Class<?> key = b.getSnippetReflection().asObject(Class.class, classNode.asJavaConstant());
+
+                Object singleton = LayeredImageSingletonSupport.singleton().runtimeLookup(key);
+                boolean conditions = singleton.getClass().equals(key) &&
+                                singleton instanceof MultiLayeredImageSingleton multiLayerSingleton &&
+                                multiLayerSingleton.getImageBuilderFlags().contains(LayeredImageSingletonBuilderFlags.RUNTIME_ACCESS);
+                VMError.guarantee(conditions, "Illegal singleton %s", singleton);
+
+                var multiLayeredArray = multiLayeredArrays.computeIfAbsent(key, k -> {
+                    var result = Array.newInstance(k, 1);
+                    Array.set(result, 0, singleton);
+                    return result;
+                });
+
+                b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(multiLayeredArray), b.getMetaAccess()));
+                return true;
+            }
+        });
+    }
+}