Rename RuntimeConditionSet to RuntimeDynamicAccessMetadata

Author: DSouzaM

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

@@ -41,7 +41,7 @@
 
 import com.oracle.svm.core.SubstrateUtil;
 import com.oracle.svm.core.c.NonmovableArrays;
-import com.oracle.svm.core.configure.RuntimeConditionSet;
+import com.oracle.svm.core.configure.RuntimeDynamicAccessMetadata;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.layeredimagesingleton.MultiLayeredImageSingleton;
@@ -356,15 +356,15 @@ private static Object decodeField(UnsafeArrayTypeReader buf, Class<?> declaringC
         boolean complete = (modifiers & COMPLETE_FLAG_MASK) != 0;
         boolean preserved = (modifiers & PRESERVED_FLAG_MASK) != 0;
 
-        RuntimeConditionSet conditions = decodeConditions(buf, layerId, preserved);
+        RuntimeDynamicAccessMetadata dynamicAccessMetadata = decodeDynamicAccessMetadata(buf, layerId, preserved);
         if (inHeap) {
             Field field = (Field) decodeObject(buf, layerId);
             if (publicOnly && !Modifier.isPublic(field.getModifiers())) {
                 /*
                  * Generate negative copy of the field. Finding a non-public field when looking for
                  * a public one should not result in a missing registration exception.
                  */
-                return ReflectionObjectFactory.newField(conditions, declaringClass, field.getName(), Object.class, field.getModifiers() | NEGATIVE_FLAG_MASK, false,
+                return ReflectionObjectFactory.newField(dynamicAccessMetadata, declaringClass, field.getName(), Object.class, field.getModifiers() | NEGATIVE_FLAG_MASK, false,
                                 null, null, ReflectionObjectFactory.FIELD_OFFSET_NONE, null, null);
             }
             if (reflectOnly) {
@@ -393,7 +393,8 @@ private static Object decodeField(UnsafeArrayTypeReader buf, Class<?> declaringC
             if (!reflectOnly) {
                 return new FieldDescriptor(declaringClass, name);
             }
-            return ReflectionObjectFactory.newField(conditions, declaringClass, name, negative ? Object.class : type, modifiers, false, null, null, ReflectionObjectFactory.FIELD_OFFSET_NONE, null,
+            return ReflectionObjectFactory.newField(dynamicAccessMetadata, declaringClass, name, negative ? Object.class : type, modifiers, false, null, null,
+                            ReflectionObjectFactory.FIELD_OFFSET_NONE, null,
                             null);
         }
         boolean trustedFinal = buf.getU1() == 1;
@@ -406,13 +407,14 @@ private static Object decodeField(UnsafeArrayTypeReader buf, Class<?> declaringC
             modifiers |= NEGATIVE_FLAG_MASK;
         }
 
-        Field reflectField = ReflectionObjectFactory.newField(conditions, declaringClass, name, type, modifiers, trustedFinal, signature, annotations, offset, deletedReason, typeAnnotations);
+        Field reflectField = ReflectionObjectFactory.newField(dynamicAccessMetadata, declaringClass, name, type, modifiers, trustedFinal, signature, annotations, offset, deletedReason,
+                        typeAnnotations);
         return reflectOnly ? reflectField : new FieldDescriptor(reflectField);
     }
 
-    private static RuntimeConditionSet decodeConditions(UnsafeArrayTypeReader buf, int layerId, boolean preserved) {
+    private static RuntimeDynamicAccessMetadata decodeDynamicAccessMetadata(UnsafeArrayTypeReader buf, int layerId, boolean preserved) {
         var conditionTypes = decodeArray(buf, Class.class, _ -> decodeType(buf, layerId), layerId);
-        return RuntimeConditionSet.createDecoded(conditionTypes, preserved);
+        return RuntimeDynamicAccessMetadata.createDecoded(conditionTypes, preserved);
     }
 
     /**
@@ -523,7 +525,7 @@ private static Object decodeExecutable(UnsafeArrayTypeReader buf, Class<?> decla
         boolean inHeap = (modifiers & IN_HEAP_FLAG_MASK) != 0;
         boolean complete = (modifiers & COMPLETE_FLAG_MASK) != 0;
         boolean preserved = (modifiers & PRESERVED_FLAG_MASK) != 0;
-        RuntimeConditionSet conditions = decodeConditions(buf, layerId, preserved);
+        RuntimeDynamicAccessMetadata dynamicAccessMetadata = decodeDynamicAccessMetadata(buf, layerId, preserved);
         if (inHeap) {
             Executable executable = (Executable) decodeObject(buf, layerId);
             if (publicOnly && !Modifier.isPublic(executable.getModifiers())) {
@@ -532,10 +534,12 @@ private static Object decodeExecutable(UnsafeArrayTypeReader buf, Class<?> decla
                  * looking for a public one should not result in a missing registration exception.
                  */
                 if (isMethod) {
-                    executable = ReflectionObjectFactory.newMethod(conditions, declaringClass, executable.getName(), executable.getParameterTypes(), Object.class, null, modifiers | NEGATIVE_FLAG_MASK,
+                    executable = ReflectionObjectFactory.newMethod(dynamicAccessMetadata, declaringClass, executable.getName(), executable.getParameterTypes(), Object.class, null,
+                                    modifiers | NEGATIVE_FLAG_MASK,
                                     null, null, null, null, null, null, null, layerId);
                 } else {
-                    executable = ReflectionObjectFactory.newConstructor(conditions, declaringClass, executable.getParameterTypes(), null, modifiers | NEGATIVE_FLAG_MASK, null, null, null, null, null,
+                    executable = ReflectionObjectFactory.newConstructor(dynamicAccessMetadata, declaringClass, executable.getParameterTypes(), null, modifiers | NEGATIVE_FLAG_MASK, null, null, null,
+                                    null, null,
                                     null);
                 }
             }
@@ -578,13 +582,13 @@ private static Object decodeExecutable(UnsafeArrayTypeReader buf, Class<?> decla
                 if (!reflectOnly) {
                     return new MethodDescriptor(declaringClass, name, (String[]) parameterTypes);
                 }
-                return ReflectionObjectFactory.newMethod(conditions, declaringClass, name, (Class<?>[]) parameterTypes, negative ? Object.class : returnType, null, modifiers,
+                return ReflectionObjectFactory.newMethod(dynamicAccessMetadata, declaringClass, name, (Class<?>[]) parameterTypes, negative ? Object.class : returnType, null, modifiers,
                                 null, null, null, null, null, null, null, layerId);
             } else {
                 if (!reflectOnly) {
                     return new ConstructorDescriptor(declaringClass, (String[]) parameterTypes);
                 }
-                return ReflectionObjectFactory.newConstructor(conditions, declaringClass, (Class<?>[]) parameterTypes, null, modifiers, null, null, null, null, null, null);
+                return ReflectionObjectFactory.newConstructor(dynamicAccessMetadata, declaringClass, (Class<?>[]) parameterTypes, null, modifiers, null, null, null, null, null, null);
             }
         }
         Class<?>[] exceptionTypes = decodeArray(buf, Class.class, _ -> decodeType(buf, layerId), layerId);
@@ -601,14 +605,14 @@ private static Object decodeExecutable(UnsafeArrayTypeReader buf, Class<?> decla
 
         Target_java_lang_reflect_Executable executable;
         if (isMethod) {
-            Method method = ReflectionObjectFactory.newMethod(conditions, declaringClass, name, (Class<?>[]) parameterTypes, returnType, exceptionTypes, modifiers,
+            Method method = ReflectionObjectFactory.newMethod(dynamicAccessMetadata, declaringClass, name, (Class<?>[]) parameterTypes, returnType, exceptionTypes, modifiers,
                             signature, annotations, parameterAnnotations, annotationDefault, accessor, reflectParameters, typeAnnotations, layerId);
             if (!reflectOnly) {
                 return new MethodDescriptor(method);
             }
             executable = SubstrateUtil.cast(method, Target_java_lang_reflect_Executable.class);
         } else {
-            Constructor<?> constructor = ReflectionObjectFactory.newConstructor(conditions, declaringClass, (Class<?>[]) parameterTypes, exceptionTypes,
+            Constructor<?> constructor = ReflectionObjectFactory.newConstructor(dynamicAccessMetadata, declaringClass, (Class<?>[]) parameterTypes, exceptionTypes,
                             modifiers, signature, annotations, parameterAnnotations, accessor, reflectParameters, typeAnnotations);
             if (!reflectOnly) {
                 return new ConstructorDescriptor(constructor);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ConditionalRuntimeValue.java

@@ -29,19 +29,19 @@
 
 /**
  * A image-heap stored {@link ConditionalRuntimeValue#value} that is guarded by run-time computed
- * {@link ConditionalRuntimeValue#conditions}.
+ * conditions.
  * </p>
- * {@link ConditionalRuntimeValue#conditions} are stored as an array to save space in the image
- * heap. This is subject to further optimizations.
+ * The conditions are stored in {@link ConditionalRuntimeValue#dynamicAccessMetadata} as an array to
+ * save space in the image heap. This is subject to further optimizations.
  *
  * @param <T> type of the stored value.
  */
 public final class ConditionalRuntimeValue<T> {
-    final RuntimeConditionSet conditions;
+    final RuntimeDynamicAccessMetadata dynamicAccessMetadata;
     volatile T value;
 
-    public ConditionalRuntimeValue(RuntimeConditionSet conditions, T value) {
-        this.conditions = conditions;
+    public ConditionalRuntimeValue(RuntimeDynamicAccessMetadata dynamicAccessMetadata, T value) {
+        this.dynamicAccessMetadata = dynamicAccessMetadata;
         this.value = value;
     }
 
@@ -50,12 +50,12 @@ public T getValueUnconditionally() {
         return value;
     }
 
-    public RuntimeConditionSet getConditions() {
-        return conditions;
+    public RuntimeDynamicAccessMetadata getDynamicAccessMetadata() {
+        return dynamicAccessMetadata;
     }
 
     public T getValue() {
-        if (conditions.satisfied()) {
+        if (dynamicAccessMetadata.satisfied()) {
             return value;
         } else {
             return null;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/RuntimeConditionSet.java renamed to substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/RuntimeDynamicAccessMetadata.java

@@ -41,32 +41,33 @@
 import com.oracle.svm.util.LogUtils;
 
 /**
- * Represents a group of {@link #conditions} that guard a value. The conditions are encoded
+ * The dynamic access metadata for some value that can be accessed at run time. Contains a set of
+ * {@link #conditions} that dictate whether the value (e.g., a resource) should be accessible; also
+ * tracks whether the value is present because it was preserved.
  * <p>
  * If any of the {@link #conditions} is satisfied then the whole set becomes also
- * {@link #satisfied}. {@link RuntimeConditionSet}s can be created at build time
+ * {@link #satisfied}. {@link RuntimeDynamicAccessMetadata}s can be created at build time
  * {@link #createHosted(AccessCondition,boolean)} and stored to the image heap, or it can be encoded
  * ({@link #getTypesForEncoding()} and later decoded at run time
  * ({@link #createDecoded(Object[], boolean)}. The current implementation does not cache
  * {@link #conditions}, although this will be implemented in the future (GR-49526)
  */
-public class RuntimeConditionSet {
+public class RuntimeDynamicAccessMetadata {
 
     private Object[] conditions;
     private boolean satisfied;
     private volatile boolean preserved;
 
     @Platforms(Platform.HOSTED_ONLY.class)
-    public static RuntimeConditionSet emptySet(boolean preserved) {
-        return new RuntimeConditionSet(new Object[0], preserved);
-
+    public static RuntimeDynamicAccessMetadata emptySet(boolean preserved) {
+        return new RuntimeDynamicAccessMetadata(new Object[0], preserved);
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
-    public static RuntimeConditionSet createHosted(AccessCondition condition, boolean preserved) {
-        var conditionSet = new RuntimeConditionSet(new Object[0], preserved);
-        conditionSet.addCondition(condition);
-        return conditionSet;
+    public static RuntimeDynamicAccessMetadata createHosted(AccessCondition condition, boolean preserved) {
+        var metadata = new RuntimeDynamicAccessMetadata(new Object[0], preserved);
+        metadata.addCondition(condition);
+        return metadata;
     }
 
     @Platforms(Platform.HOSTED_ONLY.class)
@@ -101,12 +102,12 @@ public Set<Class<?>> getTypesForEncoding() {
         }
     }
 
-    public static RuntimeConditionSet unmodifiableEmptySet() {
-        return UnmodifiableRuntimeConditionSet.UNMODIFIABLE_EMPTY_SET;
+    public static RuntimeDynamicAccessMetadata unmodifiableEmptyMetadata() {
+        return UnmodifiableRuntimeDynamicAccessMetadata.UNMODIFIABLE_EMPTY_METADATA;
     }
 
-    public static RuntimeConditionSet createDecoded(Object[] conditions, boolean preserved) {
-        return new RuntimeConditionSet(conditions, preserved);
+    public static RuntimeDynamicAccessMetadata createDecoded(Object[] conditions, boolean preserved) {
+        return new RuntimeDynamicAccessMetadata(conditions, preserved);
     }
 
     /**
@@ -160,7 +161,7 @@ public String toString() {
         return conditionsString + " = " + satisfied;
     }
 
-    private RuntimeConditionSet(Object[] conditions, boolean preserved) {
+    private RuntimeDynamicAccessMetadata(Object[] conditions, boolean preserved) {
         setConditions(conditions);
         this.preserved = preserved;
     }
@@ -199,10 +200,10 @@ private static Set<Class<?>> getTypesForEncoding(Object condition) {
         }
     }
 
-    public static final class UnmodifiableRuntimeConditionSet extends RuntimeConditionSet {
-        private static final RuntimeConditionSet UNMODIFIABLE_EMPTY_SET = new UnmodifiableRuntimeConditionSet(new Object[0]);
+    public static final class UnmodifiableRuntimeDynamicAccessMetadata extends RuntimeDynamicAccessMetadata {
+        private static final RuntimeDynamicAccessMetadata UNMODIFIABLE_EMPTY_METADATA = new UnmodifiableRuntimeDynamicAccessMetadata(new Object[0]);
 
-        private UnmodifiableRuntimeConditionSet(Object[] conditions) {
+        private UnmodifiableRuntimeDynamicAccessMetadata(Object[] conditions) {
             super(conditions, false);
         }