Automatic merge of master into galahad

Author: OracleLabsAutomation

ci/ci_common/ci-check.libsonnet

@@ -1,12 +1,18 @@
+local ci = import '../../ci.jsonnet';
 local std_get = (import 'common-utils.libsonnet').std_get;
 
 {
+  local effective_targets(build) = std.map(function(target) if std.startsWith(target, "tier") then ci.tierConfig[target] else target, build.targets),
+  local periodic_targets = ["daily", "weekly", "monthly", "post-merge", "opt-post-merge"],
+  local has_periodic_target(build) = std.length(std.setInter(std.set(effective_targets(build)), std.set(periodic_targets))) != 0,
+
   # check that all non [gate, ondemand] entries have notify_emails or notify_groups defined
   local missing_notify(builds) = {
-    [x.name]: std_get(x, "defined_in") for x in builds if !std.objectHas(x, "notify_emails") && !std.objectHasAll(x, "notify_groups") && std.length(std.setInter(std.set(x.targets), std.set(["daily", "weekly", "monthly", "post-merge", "opt-post-merge"]))) != 0
+    [x.name]: {defined_in: std_get(x, "defined_in"), targets: std_get(x, "targets")}
+    for x in builds if !std.objectHas(x, "notify_emails") && !std.objectHasAll(x, "notify_groups") && has_periodic_target(x)
   },
 
-  # check that all non entries have defined_in set
+  # check that all entries have defined_in set
   local missing_defined_in(builds) = {
     [x.name]: std_get(x, "defined_in") for x in builds if !std.objectHas(x, "defined_in")
   },

ci/ci_common/run-spec-impl.libsonnet

@@ -95,7 +95,7 @@ local std_get = (import "../../ci/ci_common/common-utils.libsonnet").std_get;
            else
              // exclusion
              assert std.length(excluded) == std.length(_values) : "Cannot mix inclusion with exclusion (either all entries start with '!' or none): " + _values;
-             std.setDiff(std.objectFieldsAll(feature_map[self.feature]), excluded)
+             std.setDiff(std.set(std.objectFieldsAll(feature_map[self.feature])), std.set(excluded))
          }
        ;
     local is_feature_desc(key) = std.member(feature_order, get_feature_value_pair(key).feature);

regex/ci/ci.jsonnet

@@ -13,17 +13,15 @@
   local regex_gate = regex_common + common.deps.eclipse + common.deps.jdt + common.deps.spotbugs + {
     name: 'gate-regex-' + self.jdk_name,
     run: [["mx", "--strict-compliance", "gate", "--strict-mode"]],
-    targets: ["gate"],
   },
 
-  local regex_gate_lite = regex_common + galahad.exclude {
+  local regex_gate_lite = regex_common + galahad.exclude + {
     name: 'weekly-regex-mac-lite-' + self.jdk_name,
     run: [
       ["mx", "build"],
       ["mx", "unittest", "--verbose", "com.oracle.truffle.regex"],
     ],
     notify_groups:: ["regex"],
-    targets: ["weekly"],
   },
 
   local regex_downstream_js = regex_common + {
@@ -38,7 +36,6 @@
       ["mx", "sversions"],
       ["mx", "gate", "--no-warning-as-error", "--all-suites", "--tags", "build,Test262-default,TestV8-default,regex"],
     ],
-    targets: ["gate"],
   },
 
   local regex_coverage = regex_common + {
@@ -56,9 +53,9 @@
 
   local _builds = [utils.add_gate_predicate(b, ["sdk", "truffle", "regex", "compiler", "vm", "substratevm"]) for b in std.flattenArrays([
       [
-        common.linux_amd64    + jdk + regex_gate,
-        common.linux_amd64    + jdk + regex_downstream_js,
-        common.darwin_aarch64 + jdk + regex_gate_lite,
+        common.linux_amd64    + jdk + common.tier1  + regex_gate,
+        common.linux_amd64    + jdk + common.tier3  + regex_downstream_js,
+        common.darwin_aarch64 + jdk + common.weekly + regex_gate_lite,
       ] for jdk in [
         common.labsjdkLatest,
       ]

substratevm/src/com.oracle.svm.agent/src/com/oracle/svm/agent/tracing/TraceFileWriter.java

@@ -31,7 +31,7 @@
 
 import com.oracle.svm.agent.tracing.core.Tracer;
 import com.oracle.svm.agent.tracing.core.TracingResultWriter;
-import com.oracle.svm.configure.trace.JsonFileWriter;
+import com.oracle.svm.configure.JsonFileWriter;
 
 public class TraceFileWriter extends Tracer implements TracingResultWriter {
     private final JsonFileWriter jsonFileWriter;

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/trace/JsonFileWriter.java renamed to substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/JsonFileWriter.java

@@ -22,7 +22,7 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package com.oracle.svm.configure.trace;
+package com.oracle.svm.configure;
 
 import java.io.BufferedWriter;
 import java.io.Closeable;
@@ -97,6 +97,10 @@ private static void printArray(JsonWriter json, Object[] array) throws IOExcepti
     }
 
     private static void printValue(JsonWriter json, Object value) throws IOException {
+        if (value instanceof JsonPrintable printable) {
+            printable.printJson(json);
+            return;
+        }
         Object s = null;
         if (value instanceof byte[]) {
             s = Base64.getEncoder().encodeToString((byte[]) value);

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/ConfigurationType.java

@@ -465,10 +465,18 @@ public synchronized void setAllPublicConstructors(ConfigurationMemberAccessibili
         }
     }
 
+    public synchronized boolean isSerializable() {
+        return serializable;
+    }
+
     public synchronized void setSerializable() {
         serializable = true;
     }
 
+    public synchronized boolean isJniAccessible() {
+        return typeJniAccessible;
+    }
+
     public synchronized void setJniAccessible() {
         typeJniAccessible = true;
     }

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/SignatureUtil.java

@@ -80,6 +80,19 @@ public static String toInternalSignature(List<?> parameterTypes) {
         return sb.append(')').toString();
     }
 
+    public static String toInternalSignature(Class<?>[] parameters) {
+        List<String> names;
+        if (parameters == null) {
+            names = List.of();
+        } else {
+            names = new ArrayList<>(parameters.length);
+            for (Class<?> parameter : parameters) {
+                names.add(parameter.getName());
+            }
+        }
+        return toInternalSignature(names);
+    }
+
     public static String toInternalClassName(String qualifiedForNameString) {
         assert qualifiedForNameString.indexOf('/') == -1 : "Requires qualified Java name, not internal representation";
         assert !qualifiedForNameString.endsWith("[]") : "Requires Class.forName syntax, for example '[Ljava.lang.String;'";

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/trace/AccessAdvisor.java

@@ -31,6 +31,7 @@
 
 import org.graalvm.collections.EconomicMap;
 
+import com.oracle.svm.configure.JsonFileWriter;
 import com.oracle.svm.configure.filters.ConfigurationFilter;
 import com.oracle.svm.configure.filters.HierarchyFilterNode;
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/ClassForNameSupport.java

@@ -47,7 +47,6 @@
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 
 import com.oracle.svm.configure.ClassNameSupport;
-import com.oracle.svm.configure.config.ConfigurationType;
 import com.oracle.svm.core.configure.ConditionalRuntimeValue;
 import com.oracle.svm.core.configure.RuntimeConditionSet;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
@@ -414,7 +413,7 @@ private Object forName0(String className, ClassLoader classLoader) {
         }
         if (MetadataTracer.enabled()) {
             // NB: the early returns above ensure we do not trace calls with bad type args.
-            MetadataTracer.singleton().traceReflectionType(className);
+            MetadataTracer.singleton().traceReflectionType(ClassNameSupport.reflectionNameToTypeName(className));
         }
         return result == NEGATIVE_QUERY ? new ClassNotFoundException(className) : result;
     }
@@ -502,10 +501,7 @@ public static Throwable getSavedException(String className) {
     public static boolean canUnsafeInstantiateAsInstance(DynamicHub hub) {
         Class<?> clazz = DynamicHub.toClass(hub);
         if (MetadataTracer.enabled()) {
-            ConfigurationType type = MetadataTracer.singleton().traceReflectionType(clazz.getName());
-            if (type != null) {
-                type.setUnsafeAllocated();
-            }
+            MetadataTracer.singleton().traceUnsafeAllocatedType(clazz);
         }
         RuntimeConditionSet conditionSet = null;
         for (var singleton : layeredSingletons()) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHub.java

@@ -24,7 +24,6 @@
  */
 package com.oracle.svm.core.hub;
 
-import static com.oracle.svm.configure.config.ConfigurationMemberInfo.ConfigurationMemberAccessibility;
 import static com.oracle.svm.configure.config.ConfigurationMemberInfo.ConfigurationMemberDeclaration;
 import static com.oracle.svm.core.MissingRegistrationUtils.throwMissingRegistrationErrors;
 import static com.oracle.svm.core.Uninterruptible.CALLED_FROM_UNINTERRUPTIBLE_CODE;
@@ -91,7 +90,6 @@
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
 
-import com.oracle.svm.configure.config.ConfigurationType;
 import com.oracle.svm.configure.config.SignatureUtil;
 import com.oracle.svm.core.BuildPhaseProvider.AfterHostedUniverse;
 import com.oracle.svm.core.BuildPhaseProvider.CompileQueueFinished;
@@ -761,7 +759,7 @@ private ReflectionMetadata reflectionMetadata() {
 
     private void checkClassFlag(int mask, String methodName) {
         if (MetadataTracer.enabled()) {
-            traceClassFlagQuery(mask);
+            MetadataTracer.singleton().traceReflectionType(toClass(this));
         }
         if (throwMissingRegistrationErrors() && !(isClassFlagSet(mask) && getConditions().satisfied())) {
             MissingReflectionRegistrationUtils.reportClassQuery(DynamicHub.toClass(this), methodName);
@@ -785,30 +783,6 @@ private static boolean isClassFlagSet(int mask, ReflectionMetadata reflectionMet
         return reflectionMetadata != null && (reflectionMetadata.classFlags & mask) != 0;
     }
 
-    private void traceClassFlagQuery(int mask) {
-        ConfigurationType type = MetadataTracer.singleton().traceReflectionType(getName());
-        if (type == null) {
-            return;
-        }
-        // TODO (GR-64765): We over-approximate member accessibility here because we don't trace
-        // accesses. Once we trace accesses, it will suffice to register the class for reflection.
-        switch (mask) {
-            case ALL_FIELDS_FLAG -> type.setAllPublicFields(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_DECLARED_FIELDS_FLAG -> type.setAllDeclaredFields(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_METHODS_FLAG -> type.setAllPublicMethods(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_DECLARED_METHODS_FLAG -> type.setAllDeclaredMethods(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_CONSTRUCTORS_FLAG -> type.setAllPublicConstructors(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_DECLARED_CONSTRUCTORS_FLAG -> type.setAllDeclaredConstructors(ConfigurationMemberAccessibility.ACCESSED);
-            case ALL_CLASSES_FLAG -> type.setAllPublicClasses();
-            case ALL_DECLARED_CLASSES_FLAG -> type.setAllDeclaredClasses();
-            case ALL_RECORD_COMPONENTS_FLAG -> type.setAllRecordComponents();
-            case ALL_PERMITTED_SUBCLASSES_FLAG -> type.setAllPermittedSubclasses();
-            case ALL_NEST_MEMBERS_FLAG -> type.setAllNestMembers();
-            case ALL_SIGNERS_FLAG -> type.setAllSigners();
-            default -> throw VMError.shouldNotReachHere("unknown class flag " + mask);
-        }
-    }
-
     /** Executed at runtime. */
     private static Object initEnumConstantsAtRuntime(Method values) {
         try {
@@ -1396,19 +1370,13 @@ private void checkField(String fieldName, Field field, boolean publicOnly) throw
     private void traceFieldLookup(String fieldName, Field field, boolean publicOnly) {
         ConfigurationMemberDeclaration declaration = publicOnly ? ConfigurationMemberDeclaration.PRESENT : ConfigurationMemberDeclaration.DECLARED;
         if (field != null) {
-            // register declaring type and field
-            ConfigurationType declaringType = MetadataTracer.singleton().traceReflectionType(field.getDeclaringClass().getName());
-            if (declaringType != null) {
-                declaringType.addField(fieldName, declaration, false);
-            }
+            // register declaring type (registers all fields for lookup)
+            MetadataTracer.singleton().traceReflectionType(field.getDeclaringClass());
             // register receiver type
-            MetadataTracer.singleton().traceReflectionType(getName());
+            MetadataTracer.singleton().traceReflectionType(toClass(this));
         } else {
             // register receiver type and negative field query
-            ConfigurationType receiverType = MetadataTracer.singleton().traceReflectionType(getName());
-            if (receiverType != null) {
-                receiverType.addField(fieldName, declaration, false);
-            }
+            MetadataTracer.singleton().traceFieldAccess(toClass(this), fieldName, declaration);
         }
     }
 
@@ -1481,35 +1449,16 @@ private boolean checkExecutableExists(String methodName, Class<?>[] parameterTyp
     private void traceMethodLookup(String methodName, Class<?>[] parameterTypes, Executable method, boolean publicOnly) {
         ConfigurationMemberDeclaration declaration = publicOnly ? ConfigurationMemberDeclaration.PRESENT : ConfigurationMemberDeclaration.DECLARED;
         if (method != null) {
-            // register declaring type and method
-            ConfigurationType declaringType = MetadataTracer.singleton().traceReflectionType(method.getDeclaringClass().getName());
-            if (declaringType != null) {
-                declaringType.addMethod(methodName, toInternalSignature(parameterTypes), declaration);
-            }
+            // register declaring type (registers all methods for lookup)
+            MetadataTracer.singleton().traceReflectionType(method.getDeclaringClass());
             // register receiver type
-            MetadataTracer.singleton().traceReflectionType(getName());
+            MetadataTracer.singleton().traceReflectionType(toClass(this));
         } else {
             // register receiver type and negative method query
-            ConfigurationType receiverType = MetadataTracer.singleton().traceReflectionType(getName());
-            if (receiverType != null) {
-                receiverType.addMethod(methodName, toInternalSignature(parameterTypes), declaration, ConfigurationMemberAccessibility.QUERIED);
-            }
+            MetadataTracer.singleton().traceMethodAccess(toClass(this), methodName, SignatureUtil.toInternalSignature(parameterTypes), declaration);
         }
     }
 
-    private static String toInternalSignature(Class<?>[] classes) {
-        List<String> names;
-        if (classes == null) {
-            names = List.of();
-        } else {
-            names = new ArrayList<>(classes.length);
-            for (Class<?> aClass : classes) {
-                names.add(aClass.getName());
-            }
-        }
-        return SignatureUtil.toInternalSignature(names);
-    }
-
     private boolean allElementsRegistered(boolean publicOnly, int allDeclaredElementsFlag, int allPublicElementsFlag) {
         return isClassFlagSet(allDeclaredElementsFlag) || (publicOnly && isClassFlagSet(allPublicElementsFlag));
     }
@@ -2025,18 +1974,14 @@ public DynamicHub arrayType() {
             throw new UnsupportedOperationException(new IllegalArgumentException());
         }
         if (MetadataTracer.enabled()) {
-            MetadataTracer.singleton().traceReflectionType(arrayTypeName());
+            MetadataTracer.singleton().traceReflectionArrayType(toClass(this));
         }
         if (companion.arrayHub == null) {
-            MissingReflectionRegistrationUtils.reportClassAccess(arrayTypeName());
+            MissingReflectionRegistrationUtils.reportClassAccess(getTypeName() + "[]");
         }
         return companion.arrayHub;
     }
 
-    private String arrayTypeName() {
-        return getTypeName() + "[]";
-    }
-
     @KeepOriginal
     private native Class<?> elementType();