[GR-54127] Merge in tag jdk-23+23

PullRequest: labsjdk-ce/76

Author: OracleLabsAutomation

.jcheck/conf

@@ -5,6 +5,7 @@ version=23
 
 [checks]
 error=author,committer,reviewers,merge,issues,executable,symlink,message,hg-tag,whitespace,problemlists
+warning=issuestitle
 
 [repository]
 tags=(?:jdk-(?:[1-9]([0-9]*)(?:\.(?:0|[1-9][0-9]*)){0,4})(?:\+(?:(?:[0-9]+))|(?:-ga)))|(?:jdk[4-9](?:u\d{1,3})?-(?:(?:b\d{2,3})|(?:ga)))|(?:hs\d\d(?:\.\d{1,2})?-b\d\d)

make/autoconf/jdk-options.m4

@@ -190,6 +190,17 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_OPTIONS],
   fi
   AC_SUBST(INCLUDE_SA)
 
+  # Setup default CDS alignment. On platforms where one build may run on machines with different
+  # page sizes, the JVM choses a compatible alignment to fit all possible page sizes. This slightly
+  # increases archive size.
+  # The only platform having this problem at the moment is Linux on aarch64, which may encounter
+  # three different page sizes: 4K, 64K, and if run on Mac m1 hardware, 16K.
+  COMPATIBLE_CDS_ALIGNMENT_DEFAULT=false
+  if test "x$OPENJDK_TARGET_OS" = "xlinux" && test "x$OPENJDK_TARGET_CPU" = "xaarch64"; then
+    COMPATIBLE_CDS_ALIGNMENT_DEFAULT=true
+  fi
+  AC_SUBST(COMPATIBLE_CDS_ALIGNMENT_DEFAULT)
+
   # Compress jars
   COMPRESS_JARS=false
 
@@ -673,7 +684,7 @@ AC_DEFUN([JDKOPT_ENABLE_DISABLE_CDS_ARCHIVE],
 #
 AC_DEFUN([JDKOPT_ENABLE_DISABLE_COMPATIBLE_CDS_ALIGNMENT],
 [
-  UTIL_ARG_ENABLE(NAME: compatible-cds-alignment, DEFAULT: false,
+  UTIL_ARG_ENABLE(NAME: compatible-cds-alignment, DEFAULT: $COMPATIBLE_CDS_ALIGNMENT_DEFAULT,
       RESULT: ENABLE_COMPATIBLE_CDS_ALIGNMENT,
       DESC: [enable use alternative compatible cds core region alignment],
       DEFAULT_DESC: [disabled],

make/conf/module-loader-map.conf

@@ -120,6 +120,7 @@ NATIVE_ACCESS_MODULES= \
     jdk.dynalink \
     jdk.httpserver \
     jdk.incubator.vector \
+    jdk.internal.le \
     jdk.internal.vm.ci \
     jdk.jfr \
     jdk.jsobject \

make/jdk/src/classes/build/tools/cldrconverter/CLDRConverter.java

@@ -87,6 +87,7 @@ public class CLDRConverter {
     static final String ZONE_NAME_PREFIX = "timezone.displayname.";
     static final String METAZONE_ID_PREFIX = "metazone.id.";
     static final String PARENT_LOCALE_PREFIX = "parentLocale.";
+    static final String LIKELY_SCRIPT_PREFIX = "likelyScript.";
     static final String META_EMPTY_ZONE_NAME = "EMPTY_ZONE";
     static final String[] EMPTY_ZONE = {"", "", "", "", "", ""};
     static final String META_ETCUTC_ZONE_NAME = "ETC_UTC";
@@ -114,9 +115,13 @@ public class CLDRConverter {
 
     // "parentLocales" map
     private static final Map<String, SortedSet<String>> parentLocalesMap = new HashMap<>();
+    static boolean nonlikelyScript;
     private static final ResourceBundle.Control defCon =
         ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT);
 
+    // "likelyScript" map
+    private static final Map<String, SortedSet<String>> likelyScriptMap = new HashMap<>();
+
     private static Set<String> AVAILABLE_TZIDS;
     static int copyrightYear;
     static String jdkHeaderTemplate;
@@ -175,7 +180,7 @@ String getKeyword() {
     private static boolean verbose;
 
     private CLDRConverter() {
-       // no instantiation
+        // no instantiation
     }
 
     @SuppressWarnings("AssignmentToForLoopParameter")
@@ -475,8 +480,8 @@ private static void parseSupplemental() throws Exception {
         parseLDMLFile(new File(SPPL_SOURCE_FILE), handlerSuppl);
         Map<String, Object> parentData = handlerSuppl.getData("root");
         parentData.keySet().stream()
-                .filter(key -> key.startsWith(PARENT_LOCALE_PREFIX))
-                .forEach(key -> {
+            .filter(key -> key.startsWith(PARENT_LOCALE_PREFIX))
+            .forEach(key -> {
                 parentLocalesMap.put(key, new TreeSet<String>(
                     Arrays.asList(((String)parentData.get(key)).split(" "))));
             });
@@ -492,6 +497,16 @@ private static void parseSupplemental() throws Exception {
         // Parse likelySubtags
         handlerLikelySubtags = new LikelySubtagsParseHandler();
         parseLDMLFile(new File(LIKELYSUBTAGS_SOURCE_FILE), handlerLikelySubtags);
+        handlerLikelySubtags.getData().forEach((from, to) -> {
+            if (!from.contains("-")) { // look for language-only tag
+                var script = to.split("-")[1];
+                var key = LIKELY_SCRIPT_PREFIX + script;
+                var prev = likelyScriptMap.putIfAbsent(key, new TreeSet<String>(Set.of(from)));
+                if (prev != null) {
+                    prev.add(from);
+                }
+            }
+        });
 
         // Parse supplementalMetadata
         // Currently interested in deprecated time zone ids and language aliases.
@@ -561,6 +576,7 @@ private static void convertBundles(List<Bundle> bundles) throws Exception {
         // for now.
         if (isBaseModule) {
             metaInfo.putAll(parentLocalesMap);
+            metaInfo.putAll(likelyScriptMap);
         }
 
         for (Bundle bundle : bundles) {
@@ -1135,7 +1151,7 @@ private static List<Locale> applyParentLocales(String baseName, List<Locale> can
         // check irregular parents
         for (int i = 0; i < candidates.size(); i++) {
             Locale l = candidates.get(i);
-            Locale p = childToParentLocaleMap.get(l);
+            Locale p = getParentLocale(l);
             if (!l.equals(Locale.ROOT) &&
                 Objects.nonNull(p) &&
                 !candidates.get(i+1).equals(p)) {
@@ -1152,6 +1168,27 @@ private static List<Locale> applyParentLocales(String baseName, List<Locale> can
         return candidates;
     }
 
+    private static Locale getParentLocale(Locale child) {
+        Locale parent = childToParentLocaleMap.get(child);
+
+        // check non-likely script for root
+        if (nonlikelyScript && parent == null && child.getCountry().isEmpty()) {
+            var lang = " " + child.getLanguage() + " ";
+            var script = child.getScript();
+
+            if (!script.isEmpty()) {
+                parent = likelyScriptMap.entrySet().stream()
+                    .filter(e -> e.getValue().contains(lang))
+                    .findAny()
+                    .map(Map.Entry::getKey)
+                    .map(likely -> likely.equals(script) ? null : Locale.ROOT)
+                    .orElse(null);
+            }
+        }
+
+        return parent;
+    }
+
     private static void generateZoneName() throws Exception {
         Files.createDirectories(Paths.get(DESTINATION_DIR, "java", "time", "format"));
         Files.write(Paths.get(DESTINATION_DIR, "java", "time", "format", "ZoneName.java"),

make/jdk/src/classes/build/tools/cldrconverter/ResourceBundleGenerator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -38,6 +38,7 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
+import java.util.stream.Collectors;
 
 class ResourceBundleGenerator implements BundleGenerator {
     // preferred timezones - keeping compatibility with JDK1.1 3 letter abbreviations
@@ -306,81 +307,77 @@ public void generateMetaInfo(Map<String, SortedSet<String>> metaInfo) throws IOE
                 import sun.util.locale.provider.LocaleProviderAdapter;
 
                 public class %s implements LocaleDataMetaInfo {
-                    private static final Map<String, String> resourceNameToLocales = HashMap.newHashMap(%d);
-                %s
-                    static {
-                """, CLDRConverter.isBaseModule ? "cldr" : "resources.cldr.provider",
-                className, metaInfo.keySet().stream().filter(k -> k.equals("AvailableLocales")).count(),
-                CLDRConverter.isBaseModule ?
-                    """
+                """,
+                    CLDRConverter.isBaseModule ? "cldr" : "resources.cldr.provider",
+                    className);
+
+            if (CLDRConverter.isBaseModule) {
+                out.printf("""
                         private static final Map<Locale, String[]> parentLocalesMap = HashMap.newHashMap(%d);
                         private static final Map<String, String> languageAliasMap = HashMap.newHashMap(%d);
+                        static final boolean nonlikelyScript = %s; // package access from CLDRLocaleProviderAdapter
+
+                        static {
                     """.formatted(
                         metaInfo.keySet().stream().filter(k -> k.startsWith(CLDRConverter.PARENT_LOCALE_PREFIX)).count(),
-                        CLDRConverter.handlerSupplMeta.getLanguageAliasData().size()) :
-                    "");
-
-            for (String key : metaInfo.keySet()) {
-                if (key.startsWith(CLDRConverter.PARENT_LOCALE_PREFIX)) {
-                    String parentTag = key.substring(CLDRConverter.PARENT_LOCALE_PREFIX.length());
-                    if ("root".equals(parentTag)) {
-                        out.printf("        parentLocalesMap.put(Locale.ROOT,\n");
-                    } else {
-                        out.printf("        parentLocalesMap.put(Locale.forLanguageTag(\"%s\"),\n",
-                                   parentTag);
-                    }
-                    String[] children = toLocaleList(metaInfo.get(key), true).split(" ");
-                    Arrays.sort(children);
-                    out.printf("            new String[] {\n" +
-                               "                ");
-                    int count = 0;
-                    for (int i = 0; i < children.length; i++) {
-                        String child = children[i];
-                        out.printf("\"%s\", ", child);
-                        count += child.length() + 4;
-                        if (i != children.length - 1 && count > 64) {
-                            out.printf("\n                ");
-                            count = 0;
+                        CLDRConverter.handlerSupplMeta.getLanguageAliasData().size(),
+                        Boolean.valueOf(CLDRConverter.nonlikelyScript)));
+
+                for (String key : metaInfo.keySet()) {
+                    if (key.startsWith(CLDRConverter.PARENT_LOCALE_PREFIX)) {
+                        String parentTag = key.substring(CLDRConverter.PARENT_LOCALE_PREFIX.length());
+                        if ("root".equals(parentTag)) {
+                            out.printf("        parentLocalesMap.put(Locale.ROOT,\n");
+                        } else {
+                            out.printf("        parentLocalesMap.put(Locale.forLanguageTag(\"%s\"),\n",
+                                    parentTag);
                         }
-                    }
-                    out.printf("\n            });\n");
-                } else {
-                    if ("AvailableLocales".equals(key)) {
-                        out.printf("        resourceNameToLocales.put(\"%s\",\n", key);
-                        out.printf("            \"%s\");\n", toLocaleList(applyLanguageAliases(metaInfo.get(key)), false));
+                        generateStringArray(metaInfo.get(key), out);
                     }
                 }
-            }
-            // for languageAliasMap
-            if (CLDRConverter.isBaseModule) {
+                out.println();
+
+                // for languageAliasMap
                 CLDRConverter.handlerSupplMeta.getLanguageAliasData().forEach((key, value) -> {
                     out.printf("        languageAliasMap.put(\"%s\", \"%s\");\n", key, value);
                 });
-            }
+                out.printf("    }\n\n");
 
-            out.printf("    }\n\n");
+                // end of static initializer block.
 
-            // end of static initializer block.
-
-            // Canonical TZ names for delayed initialization
-            if (CLDRConverter.isBaseModule) {
+                // Delayed initialization section
                 out.printf("""
-                               private static class TZCanonicalIDMapHolder {
-                                   static final Map<String, String> tzCanonicalIDMap = HashMap.newHashMap(%d);
+                               private static class CLDRMapHolder {
+                                   private static final Map<String, String> tzCanonicalIDMap = HashMap.newHashMap(%d);
+                                   private static final Map<String, String> likelyScriptMap = HashMap.newHashMap(%d);
+
                                    static {
-                           """, CLDRConverter.handlerTimeZone.getData().size());
+                           """, CLDRConverter.handlerTimeZone.getData().size(),
+                                metaInfo.keySet().stream().filter(k -> k.startsWith(CLDRConverter.LIKELY_SCRIPT_PREFIX)).count());
                 CLDRConverter.handlerTimeZone.getData().entrySet().stream()
                     .forEach(e -> {
                         String[] ids = ((String)e.getValue()).split("\\s");
                         out.printf("            tzCanonicalIDMap.put(\"%s\", \"%s\");\n", e.getKey(),
-                                ids[0]);
+                            ids[0]);
                         for (int i = 1; i < ids.length; i++) {
                             out.printf("            tzCanonicalIDMap.put(\"%s\", \"%s\");\n", ids[i],
                                 ids[0]);
                         }
                     });
-                out.printf("        }\n    }\n\n");
+                out.println();
+
+                // for likelyScript map
+                for (String key : metaInfo.keySet()) {
+                    if (key.startsWith(CLDRConverter.LIKELY_SCRIPT_PREFIX)) {
+                        // ensure spaces at the begin/end for delimiting purposes
+                        out.printf("            likelyScriptMap.put(\"%s\", \"%s\");\n",
+                                key.substring(CLDRConverter.LIKELY_SCRIPT_PREFIX.length()),
+                                " " + metaInfo.get(key).stream().collect(Collectors.joining(" ")) + " ");
+                    }
+                }
+                out.printf("        }\n    }\n");
             }
+            out.println();
 
             out.printf("""
                     @Override
@@ -390,12 +387,13 @@ public LocaleProviderAdapter.Type getType() {
 
                     @Override
                     public String availableLanguageTags(String category) {
-                        return resourceNameToLocales.getOrDefault(category, "");
+                        return " %s";
                     }
-                    %s
-                }
                 """,
-                CLDRConverter.isBaseModule ? """
+                toLocaleList(applyLanguageAliases(metaInfo.get("AvailableLocales")), false));
+
+            if(CLDRConverter.isBaseModule) {
+                out.printf("""
 
                     @Override
                     public Map<String, String> getLanguageAliasMap() {
@@ -404,16 +402,41 @@ public Map<String, String> getLanguageAliasMap() {
 
                     @Override
                     public Map<String, String> tzCanonicalIDs() {
-                        return TZCanonicalIDMapHolder.tzCanonicalIDMap;
+                        return CLDRMapHolder.tzCanonicalIDMap;
                     }
 
                     public Map<Locale, String[]> parentLocales() {
                         return parentLocalesMap;
                     }
-                """ : "");
+
+                    // package access from CLDRLocaleProviderAdapter
+                    Map<String, String> likelyScriptMap() {
+                        return CLDRMapHolder.likelyScriptMap;
+                    }
+                """);
+            }
+            out.printf("}\n");
         }
     }
 
+    private static void generateStringArray(SortedSet<String> set, PrintWriter out) throws IOException {
+        String[] children = toLocaleList(set, true).split(" ");
+        Arrays.sort(children);
+        out.printf("            new String[] {\n" +
+                "                ");
+        int count = 0;
+        for (int i = 0; i < children.length; i++) {
+            String child = children[i];
+            out.printf("\"%s\", ", child);
+            count += child.length() + 4;
+            if (i != children.length - 1 && count > 64) {
+                out.printf("\n                ");
+                count = 0;
+            }
+        }
+        out.printf("\n            });\n");
+    }
+
     private static final Locale.Builder LOCALE_BUILDER = new Locale.Builder();
     private static boolean isBaseLocale(String localeID) {
         localeID = localeID.replaceAll("-", "_");
@@ -433,7 +456,9 @@ private static String toLocaleList(SortedSet<String> set, boolean all) {
                 if (!all && CLDRConverter.isBaseModule ^ isBaseLocale(id)) {
                     continue;
                 }
-                sb.append(' ');
+                if (sb.length() > 0) {
+                    sb.append(' ');
+                }
                 sb.append(id);
             }
         }