[GR-59855] Make StaticFinalFieldFoldingFeature layer aware

PullRequest: graal/19639

Author: Zeavee

substratevm/src/com.oracle.svm.hosted/resources/SharedLayerSnapshotCapnProtoSchema.capnp

@@ -133,7 +133,6 @@ struct PersistedAnalysisField {
   isSynthetic @13 :Bool;
   annotationList @14 :List(Annotation);
   name @15 :Text;
-  fieldCheckIndex @16 :Int32;
 }
 
 struct CEntryPointLiteralReference {
@@ -258,6 +257,15 @@ struct SharedLayerSnapshot {
   singletonObjects @12 :List(ImageSingletonObject);
   fields @13 :List(PersistedAnalysisField);
   nextLayerNumber @14 :Int32;
+  staticFinalFieldFoldingSingleton @15 :StaticFinalFieldFoldingSingleton;
+}
+
+struct StaticFinalFieldFoldingSingleton {
+  fields @0 :List(FieldId);
+  fieldCheckIndexes @1 :List(Int32);
+  fieldInitializationStatusList @2 :List(Bool);
+  bytecodeParsedFoldedFieldValues @3 :List(ConstantReference);
+  afterParsingHooksDoneFoldedFieldValues @4 :List(ConstantReference);
 }
 
 struct PrimitiveValue {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/fieldfolding/IsStaticFinalFieldInitializedNode.java

@@ -44,7 +44,7 @@
 
 /**
  * Node that checks if a static final field is initialized. This is basically just a load of the
- * value in the {@link StaticFinalFieldFoldingFeature#fieldInitializationStatus} array. But we
+ * value in the {@link StaticFinalFieldFoldingSingleton#fieldInitializationStatus} array. But we
  * cannot immediately emit a {@link LoadIndexedNode} in the bytecode parser because we do not know
  * at the time of parsing if the declaring class of the field is initialized at image build time.
  */
@@ -87,10 +87,10 @@ public void simplify(SimplifierTool tool) {
             replacementNode = ConstantNode.forBoolean(true, graph());
 
         } else {
-            StaticFinalFieldFoldingFeature feature = StaticFinalFieldFoldingFeature.singleton();
-            Integer fieldCheckIndex = feature.getFieldCheckIndex(field);
+            StaticFinalFieldFoldingSingleton singleton = StaticFinalFieldFoldingSingleton.singleton();
+            Integer fieldCheckIndex = singleton.getFieldCheckIndex(field);
             assert fieldCheckIndex != null : "Field must be optimizable: " + field;
-            ConstantNode fieldInitializationStatusNode = ConstantNode.forConstant(tool.getSnippetReflection().forObject(feature.fieldInitializationStatus), tool.getMetaAccess(), graph());
+            ConstantNode fieldInitializationStatusNode = ConstantNode.forConstant(tool.getSnippetReflection().forObject(singleton.fieldInitializationStatus), tool.getMetaAccess(), graph());
             ConstantNode fieldCheckIndexNode = ConstantNode.forInt(fieldCheckIndex, graph());
 
             replacementNode = graph().addOrUniqueWithInputs(LoadIndexedNode.create(graph().getAssumptions(), fieldInitializationStatusNode, fieldCheckIndexNode,

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/fieldfolding/MarkStaticFinalFieldInitializedNode.java

@@ -43,10 +43,10 @@
 
 /**
  * Node that marks a static final field as initialized. This is basically just a store of the value
- * true in the {@link StaticFinalFieldFoldingFeature#fieldInitializationStatus} array. But we cannot
- * immediately emit a {@link StoreIndexedNode} in the bytecode parser because we do not know at the
- * time of parsing if the field can actually be optimized or not. So this node is emitted for every
- * static final field store, and then just removed if the field cannot be optimized.
+ * true in the {@link StaticFinalFieldFoldingSingleton#fieldInitializationStatus} array. But we
+ * cannot immediately emit a {@link StoreIndexedNode} in the bytecode parser because we do not know
+ * at the time of parsing if the field can actually be optimized or not. So this node is emitted for
+ * every static final field store, and then just removed if the field cannot be optimized.
  */
 @NodeInfo(size = NodeSize.SIZE_1, cycles = NodeCycles.CYCLES_1)
 public final class MarkStaticFinalFieldInitializedNode extends AbstractStateSplit implements Simplifiable {
@@ -75,10 +75,10 @@ public void simplify(SimplifierTool tool) {
         }
         assert field instanceof HostedField;
 
-        StaticFinalFieldFoldingFeature feature = StaticFinalFieldFoldingFeature.singleton();
-        Integer fieldCheckIndex = feature.getFieldCheckIndex(field);
+        StaticFinalFieldFoldingSingleton singleton = StaticFinalFieldFoldingSingleton.singleton();
+        Integer fieldCheckIndex = singleton.getFieldCheckIndex(field);
         if (fieldCheckIndex != null) {
-            ConstantNode fieldInitializationStatusNode = ConstantNode.forConstant(tool.getSnippetReflection().forObject(feature.fieldInitializationStatus), tool.getMetaAccess(), graph());
+            ConstantNode fieldInitializationStatusNode = ConstantNode.forConstant(tool.getSnippetReflection().forObject(singleton.fieldInitializationStatus), tool.getMetaAccess(), graph());
             ConstantNode fieldCheckIndexNode = ConstantNode.forInt(fieldCheckIndex, graph());
             ConstantNode trueNode = ConstantNode.forBoolean(true, graph());
             StoreIndexedNode replacementNode = graph().add(new StoreIndexedNode(fieldInitializationStatusNode, fieldCheckIndexNode, null, null, JavaKind.Boolean, trueNode));