No add-opens

src/hotspot/share/runtime/arguments.cpp

@@ -1337,6 +1337,7 @@ bool Arguments::add_property(const char* prop, PropertyWriteable writeable, Prop
     log_info(cds)("optimized module handling: disabled due to incompatible property: %s=%s", key, value);
   }
   if (strcmp(key, "jdk.module.showModuleResolution") == 0 ||
+      strcmp(key, "jdk.module.jbrNoIllegalAccess") != 0 ||
       strcmp(key, "jdk.module.validation") == 0 ||
       strcmp(key, "java.system.class.loader") == 0) {
     MetaspaceShared::disable_full_module_graph();
@@ -2131,7 +2132,8 @@ bool Arguments::parse_uintx(const char* value,
 }
 
 bool Arguments::create_module_property(const char* prop_name, const char* prop_value, PropertyInternal internal) {
-  assert(is_internal_module_property(prop_name), "unknown module property: '%s'", prop_name);
+  assert(is_internal_module_property(prop_name) ||
+         strcmp(prop_name, "jdk.module.jbrNoIllegalAccess") == 0, "unknown module property: '%s'", prop_name);
   size_t prop_len = strlen(prop_name) + strlen(prop_value) + 2;
   char* property = AllocateHeap(prop_len, mtArguments);
   int ret = jio_snprintf(property, prop_len, "%s=%s", prop_name, prop_value);
@@ -2499,10 +2501,11 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_m
       if (res != JNI_OK) {
         return res;
       }
-    } else if (match_option(option, "--illegal-access=", &tail)) {
-      char version[256];
-      JDK_Version::jdk(17).to_string(version, sizeof(version));
-      warning("Ignoring option %s; support was removed in %s", option->optionString, version);
+    } else if (match_option(option, "--jbr-no-illegal-access=", &tail)) {
+      warning("Option --jbr-no-illegal-access is for tests only and will be removed in a future release.");
+      if (!create_module_property("jdk.module.jbrNoIllegalAccess", tail, ExternalProperty)) {
+        return JNI_ENOMEM;
+      }
     // -agentlib and -agentpath
     } else if (match_option(option, "-agentlib:", &tail) ||
           (is_absolute_path = match_option(option, "-agentpath:", &tail))) {

src/java.base/share/classes/jdk/internal/module/ExplodedSystemModules.java

@@ -68,4 +68,14 @@ class ExplodedSystemModules implements SystemModules {
     public Map<String, Set<String>> moduleReads() {
         throw new InternalError();
     }
+
+    @Override
+    public  Map<String, Set<String>> concealedPackagesToOpen() {
+        return Map.of();
+    }
+
+    @Override
+    public  Map<String, Set<String>> exportedPackagesToOpen() {
+        return Map.of();
+    }
 }

src/java.base/share/classes/jdk/internal/module/IllegalAccessMaps.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2017, 2019, 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 jdk.internal.module;
+
+import sun.nio.cs.UTF_8;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UncheckedIOException;
+import java.lang.module.ModuleDescriptor;
+import java.lang.module.ModuleFinder;
+import java.lang.module.ModuleReference;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Generates the maps of concealed and exported packages to open at run-time.
+ *
+ * This is used at run-time for exploded builds, and at link-time to generate
+ * the maps for the system modules in the run-time image.
+ */
+
+public class IllegalAccessMaps {
+    private final Map<String, Set<String>> concealedPackagesToOpen;
+    private final Map<String, Set<String>> exportedPackagesToOpen;
+
+    private IllegalAccessMaps(Map<String, Set<String>> map1,
+                              Map<String, Set<String>> map2) {
+        this.concealedPackagesToOpen = map1;
+        this.exportedPackagesToOpen = map2;
+    }
+
+    /**
+     * Returns the map of concealed packages to open. The map key is the
+     * module name, the value is the set of concealed packages to open.
+     */
+    public Map<String, Set<String>> concealedPackagesToOpen() {
+        return concealedPackagesToOpen;
+    }
+
+    /**
+     * Returns the map of exported packages to open. The map key is the
+     * module name, the value is the set of exported packages to open.
+     */
+    public Map<String, Set<String>> exportedPackagesToOpen() {
+        return exportedPackagesToOpen;
+    }
+
+    /**
+     * Generate the maps of module to concealed and exported packages for
+     * the system modules that are observable with the given module finder.
+     */
+    public static IllegalAccessMaps generate(ModuleFinder finder) {
+        Map<String, ModuleDescriptor> map = new HashMap<>();
+        finder.findAll().stream()
+            .map(ModuleReference::descriptor)
+            .forEach(md -> md.packages().forEach(pn -> map.putIfAbsent(pn, md)));
+
+        Map<String, Set<String>> concealedPackagesToOpen = new HashMap<>();
+        Map<String, Set<String>> exportedPackagesToOpen = new HashMap<>();
+
+        String rn = "jdk8_packages.dat";
+        InputStream in = IllegalAccessMaps.class.getResourceAsStream(rn);
+        if (in == null) {
+            throw new InternalError(rn + " not found");
+        }
+        try (BufferedReader br = new BufferedReader(
+                new InputStreamReader(in, UTF_8.INSTANCE)))
+        {
+            br.lines()
+                .filter(line -> !line.isEmpty() && !line.startsWith("#"))
+                .forEach(pn -> {
+                    ModuleDescriptor descriptor = map.get(pn);
+                    if (descriptor != null && !isOpen(descriptor, pn)) {
+                        String name = descriptor.name();
+                        if (isExported(descriptor, pn)) {
+                            exportedPackagesToOpen.computeIfAbsent(name,
+                                    k -> new HashSet<>()).add(pn);
+                        } else {
+                            concealedPackagesToOpen.computeIfAbsent(name,
+                                    k -> new HashSet<>()).add(pn);
+                        }
+                    }
+                });
+
+        } catch (IOException ioe) {
+            throw new UncheckedIOException(ioe);
+        }
+
+        return new IllegalAccessMaps(concealedPackagesToOpen, exportedPackagesToOpen);
+    }
+
+    private static boolean isExported(ModuleDescriptor descriptor, String pn) {
+        return descriptor.exports()
+                .stream()
+                .anyMatch(e -> e.source().equals(pn) && !e.isQualified());
+    }
+
+    private static boolean isOpen(ModuleDescriptor descriptor, String pn) {
+        return descriptor.opens()
+                .stream()
+                .anyMatch(e -> e.source().equals(pn) && !e.isQualified());
+    }
+}

src/java.base/share/classes/jdk/internal/module/ModuleBootstrap.java

@@ -147,7 +147,8 @@ public final class ModuleBootstrap {
                getProperty("jdk.module.limitmods") == null &&     // --limit-modules
                getProperty("jdk.module.addreads.0") == null &&    // --add-reads
                getProperty("jdk.module.addexports.0") == null &&  // --add-exports
-               getProperty("jdk.module.addopens.0") == null;      // --add-opens
+               getProperty("jdk.module.addopens.0") == null &&    // --add-opens
+               getProperty("jdk.module.jbrNoIllegalAccess") != null; // --jbr-noillegal-access
     }
 
     /**
@@ -188,6 +189,7 @@ public final class ModuleBootstrap {
         String mainModule = System.getProperty("jdk.module.main");
         Set<String> addModules = addModules();
         Set<String> limitModules = limitModules();
+        String jbrNoIllegalAccess = getAndRemoveProperty("jdk.module.jbrNoIllegalAccess");
 
         PrintStream traceOutput = null;
         String trace = getAndRemoveProperty("jdk.module.showModuleResolution");
@@ -219,7 +221,8 @@ public final class ModuleBootstrap {
                 && !haveModulePath
                 && addModules.isEmpty()
                 && limitModules.isEmpty()
-                && !isPatched) {
+                && !isPatched
+                && jbrNoIllegalAccess != null) {
             systemModuleFinder = archivedModuleGraph.finder();
             hasSplitPackages = archivedModuleGraph.hasSplitPackages();
             hasIncubatorModules = archivedModuleGraph.hasIncubatorModules();
@@ -454,10 +457,19 @@ public final class ModuleBootstrap {
             checkIncubatingStatus(cf);
         }
 
-        // --add-reads, --add-exports/--add-opens
+        // --add-reads, --add-exports/--add-opens, and --jbr-no-illegal-access
         addExtraReads(bootLayer);
         boolean extraExportsOrOpens = addExtraExportsAndOpens(bootLayer);
 
+        if (jbrNoIllegalAccess == null) {
+            assert systemModules != null;
+            addIllegalAccess(jbrNoIllegalAccess,
+                             systemModules,
+                             upgradeModulePath,
+                             bootLayer,
+                             extraExportsOrOpens);
+        }
+
         // add enable native access
         addEnableNativeAccess(bootLayer);
 
@@ -813,6 +825,77 @@ public final class ModuleBootstrap {
         return modules;
     }
 
+    /**
+     * Process the --illegal-access option to open packages of system modules
+     * in the boot layer to code in unnamed modules.
+     */
+    private static void addIllegalAccess(String illegalAccess,
+                                         SystemModules systemModules,
+                                         ModuleFinder upgradeModulePath,
+                                         ModuleLayer bootLayer,
+                                         boolean extraExportsOrOpens) {
+
+        if (illegalAccess != null && illegalAccess.equals("yes"))
+            return;  // nothing to do
+
+        Map<String, Set<String>> concealedPackagesToOpen = systemModules.concealedPackagesToOpen();
+        Map<String, Set<String>> exportedPackagesToOpen = systemModules.exportedPackagesToOpen();
+        if (concealedPackagesToOpen.isEmpty() && exportedPackagesToOpen.isEmpty()) {
+            // need to generate (exploded build)
+            IllegalAccessMaps maps = IllegalAccessMaps.generate(limitedFinder());
+            concealedPackagesToOpen = maps.concealedPackagesToOpen();
+            exportedPackagesToOpen = maps.exportedPackagesToOpen();
+        }
+
+        // open specific packages in the system modules
+        Set<String> emptySet = Set.of();
+        for (Module m : bootLayer.modules()) {
+            ModuleDescriptor descriptor = m.getDescriptor();
+            String name = m.getName();
+
+            // skip open modules
+            if (descriptor.isOpen()) {
+                continue;
+            }
+
+            // skip modules loaded from the upgrade module path
+            if (upgradeModulePath != null
+                && upgradeModulePath.find(name).isPresent()) {
+                continue;
+            }
+
+            Set<String> concealedPackages = concealedPackagesToOpen.getOrDefault(name, emptySet);
+            Set<String> exportedPackages = exportedPackagesToOpen.getOrDefault(name, emptySet);
+
+            // refresh the set of concealed and exported packages if needed
+            if (extraExportsOrOpens) {
+                concealedPackages = new HashSet<>(concealedPackages);
+                exportedPackages = new HashSet<>(exportedPackages);
+                Iterator<String> iterator = concealedPackages.iterator();
+                while (iterator.hasNext()) {
+                    String pn = iterator.next();
+                    if (m.isExported(pn, BootLoader.getUnnamedModule())) {
+                        // concealed package is exported to ALL-UNNAMED
+                        iterator.remove();
+                        exportedPackages.add(pn);
+                    }
+                }
+                iterator = exportedPackages.iterator();
+                while (iterator.hasNext()) {
+                    String pn = iterator.next();
+                    if (m.isOpen(pn, BootLoader.getUnnamedModule())) {
+                        // exported package is opened to ALL-UNNAMED
+                        iterator.remove();
+                    }
+                }
+            }
+
+            // open the packages to unnamed modules
+            JLA.addOpensToAllUnnamed(m, concealedPackages, exportedPackages);
+        }
+
+    }
+
     /**
      * Decodes the values of --add-reads, -add-exports, --add-opens or
      * --patch-modules options that are encoded in system properties.

src/java.base/share/classes/jdk/internal/module/SystemModules.java

@@ -83,4 +83,16 @@ interface SystemModules {
      * by this SystemModules object.
      */
     Map<String, Set<String>> moduleReads();
+
+    /**
+     * Returns the map of module concealed packages to open. The map key is the
+     * module name, the value is the set of concealed packages to open.
+     */
+    Map<String, Set<String>> concealedPackagesToOpen();
+
+    /**
+     * Returns the map of module exported packages to open. The map key is the
+     * module name, the value is the set of exported packages to open.
+     */
+    Map<String, Set<String>> exportedPackagesToOpen();
 }

src/java.base/share/classes/sun/launcher/resources/launcher.properties

@@ -188,6 +188,11 @@ java.launcher.X.usage=\n\
 \    --add-opens <module>/<package>=<target-module>(,<target-module>)*\n\
 \                      updates <module> to open <package> to\n\
 \                      <target-module>, regardless of module declaration.\n\
+\    --jbr-no-illegal-access=<value>\n\
+\                      permit or deny access to members of types in named modules\n\
+\                      by code in unnamed modules.\n\
+\                      <value> is only "yes"\n\
+\                      This option will be removed in a future release.\n\
 \    --limit-modules <module name>[,<module name>...]\n\
 \                      limit the universe of observable modules\n\
 \    --patch-module <module>=<file>({0}<file>)*\n\

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/plugins/SystemModulesPlugin.java

@@ -60,6 +60,7 @@ import java.util.stream.Collectors;
 
 import jdk.internal.module.Checks;
 import jdk.internal.module.DefaultRoots;
+import jdk.internal.module.IllegalAccessMaps;
 import jdk.internal.module.Modules;
 import jdk.internal.module.ModuleHashes;
 import jdk.internal.module.ModuleInfo.Attributes;
@@ -621,6 +622,9 @@ public final class SystemModulesPlugin extends AbstractPlugin {
             // generate moduleReads
             genModuleReads(cw, cf);
 
+            // generate concealedPackagesToOpen and exportedPackagesToOpen
+            genXXXPackagesToOpenMethods(cw);
+
             return cw;
         }
 
@@ -851,6 +855,16 @@ public final class SystemModulesPlugin extends AbstractPlugin {
             generate(cw, "moduleReads", map, true);
         }
 
+        /**
+         * Generate concealedPackagesToOpen and exportedPackagesToOpen methods.
+         */
+        private void genXXXPackagesToOpenMethods(ClassWriter cw) {
+            ModuleFinder finder = finderOf(moduleInfos);
+            IllegalAccessMaps maps = IllegalAccessMaps.generate(finder);
+            generate(cw, "concealedPackagesToOpen", maps.concealedPackagesToOpen(), false);
+            generate(cw, "exportedPackagesToOpen", maps.exportedPackagesToOpen(), false);
+        }
+
         /**
          * Generate method to return {@code Map<String, Set<String>>}.
          *