8240567: MethodTooLargeException thrown while creating a jlink image

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

@@ -118,10 +118,15 @@ public final class SystemModulesPlugin extends AbstractPlugin {
             ClassDesc.ofInternalName("jdk/internal/module/SystemModules");
     private static final ClassDesc CD_SYSTEM_MODULES_MAP =
             ClassDesc.ofInternalName(SYSTEM_MODULES_MAP_CLASSNAME);
+    private final int moduleDescriptorsPerMethod;
     private boolean enabled;
 
     public SystemModulesPlugin() {
+        this(75);
+    }
+    public SystemModulesPlugin(int moduleDescriptorsPerMethod) {
         super("system-modules");
+        this.moduleDescriptorsPerMethod = moduleDescriptorsPerMethod;
         this.enabled = true;
     }
 
@@ -316,7 +321,7 @@ private String genSystemModulesClass(List<ModuleInfo> moduleInfos,
                                          String className,
                                          ResourcePoolBuilder out) {
         SystemModulesClassGenerator generator
-            = new SystemModulesClassGenerator(className, moduleInfos);
+            = new SystemModulesClassGenerator(className, moduleInfos, moduleDescriptorsPerMethod);
         byte[] bytes = generator.genClassBytes(cf);
         String rn = "/java.base/" + className + ".class";
         ResourcePoolEntry e = ResourcePoolEntry.create(rn, bytes);
@@ -531,16 +536,20 @@ static class SystemModulesClassGenerator {
         // list of all ModuleInfos
         private final List<ModuleInfo> moduleInfos;
 
+        private final int moduleDescriptorsPerMethod;
+
         // A builder to create one single Set instance for a given set of
         // names or modifiers to reduce the footprint
         // e.g. target modules of qualified exports
         private final DedupSetBuilder dedupSetBuilder
             = new DedupSetBuilder(this::getNextLocalVar);
 
         public SystemModulesClassGenerator(String className,
-                                           List<ModuleInfo> moduleInfos) {
+                                           List<ModuleInfo> moduleInfos,
+                                           int moduleDescriptorsPerMethod) {
             this.classDesc = ClassDesc.ofInternalName(className);
             this.moduleInfos = moduleInfos;
+            this.moduleDescriptorsPerMethod = moduleDescriptorsPerMethod;
             moduleInfos.forEach(mi -> dedups(mi.descriptor()));
         }
 
@@ -666,7 +675,7 @@ private void genIncubatorModules(ClassBuilder clb) {
          * Generate bytecode for moduleDescriptors method
          */
         private void genModuleDescriptorsMethod(ClassBuilder clb) {
-            if (moduleInfos.size() <= 75) {
+            if (moduleInfos.size() <= moduleDescriptorsPerMethod) {
                 clb.withMethodBody(
                         "moduleDescriptors",
                         MethodTypeDesc.of(CD_MODULE_DESCRIPTOR.arrayType()),
@@ -678,20 +687,34 @@ private void genModuleDescriptorsMethod(ClassBuilder clb) {
                             for (int index = 0; index < moduleInfos.size(); index++) {
                                 ModuleInfo minfo = moduleInfos.get(index);
                                 new ModuleDescriptorBuilder(cob,
-                                        minfo.descriptor(),
-                                        minfo.packages(),
-                                        index).build();
+                                                            minfo.descriptor(),
+                                                            minfo.packages(),
+                                                            index).build();
                             }
                             cob.aload(MD_VAR)
                                .areturn();
                         });
                 return;
             }
 
+            // Instead of adding the module descriptor calls in this method,
+            // helper methods are created in separate helper methods.
+            // Let m1, m2, ..., mn be the calls to the module descriptor builder
+            // Here, n is larger than moduleDescriptorsPerMethod, which will hit the 64kb limit of method length.
+            // thus, we create f1, f2, ... where
+            //   - f1 calls m1, ... m_{moduleDescriptorsPerMethod-1},
+            //   - f2 calls m_{moduleDescriptorsPerMethod}, ... m_{2xmoduleDescriptorsPerMethod-1},
+            //   - etc.
+            //
+            // Inside m, the class SystemModulesClassGenerator.DedupSetBuilder is used.
+            // That class creates sets caching variables. It stores its caches in the local storage.
+            // Since the local storage is destroyed across each method, but the sets are needed across methods,
+            // the local variables are passed on to the next helper method using a list of these variables.
+
             List<List<ModuleInfo>> splitModuleInfos = new ArrayList<>();
             List<ModuleInfo> currentModuleInfos = null;
             for (int index = 0; index < moduleInfos.size(); index++) {
-                if (index % 75 == 0) {
+                if (index % moduleDescriptorsPerMethod == 0) {
                     currentModuleInfos = new ArrayList<>();
                     splitModuleInfos.add(currentModuleInfos);
                 }
@@ -748,9 +771,9 @@ private void genModuleDescriptorsMethod(ClassBuilder clb) {
                             for (int j = 0; j < moduleInfosPackage.size(); j++) {
                                 ModuleInfo minfo = moduleInfosPackage.get(j);
                                 new ModuleDescriptorBuilder(cob,
-                                        minfo.descriptor(),
-                                        minfo.packages(),
-                                        globalCount[0]).build();
+                                                            minfo.descriptor(),
+                                                            minfo.packages(),
+                                                            globalCount[0]).build();
                                 globalCount[0]++;
                             }