29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.lang.module.ModuleDescriptor;
32 import java.lang.module.ModuleDescriptor.*;
33 import java.util.ArrayList;
34 import java.util.Collection;
35 import java.util.EnumSet;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Objects;
41 import java.util.Set;
42 import java.util.function.IntSupplier;
43
44 import jdk.internal.misc.JavaLangModuleAccess;
45 import jdk.internal.misc.SharedSecrets;
46 import jdk.internal.module.Checks;
47 import jdk.internal.module.ModuleInfoExtender;
48 import jdk.internal.module.SystemModules;
49 import jdk.internal.org.objectweb.asm.ClassWriter;
50 import jdk.internal.org.objectweb.asm.MethodVisitor;
51 import jdk.internal.org.objectweb.asm.Opcodes;
52
53 import static jdk.internal.org.objectweb.asm.Opcodes.*;
54
55 import jdk.tools.jlink.plugin.PluginException;
56 import jdk.tools.jlink.plugin.ResourcePool;
57 import jdk.tools.jlink.plugin.Plugin;
58 import jdk.tools.jlink.internal.plugins.SystemModuleDescriptorPlugin.SystemModulesClassGenerator.*;
59 import jdk.tools.jlink.plugin.ResourcePoolBuilder;
60 import jdk.tools.jlink.plugin.ResourcePoolEntry;
61
62 /**
63 * Jlink plugin to reconstitute module descriptors for system modules.
64 * It will extend module-info.class with Packages attribute,
65 * if not present. It also determines the number of packages of
66 * the boot layer at link time.
67 *
68 * This plugin will override jdk.internal.module.SystemModules class
506 uses(md.uses());
507
508 // provides
509 provides(md.provides());
510
511 // all packages
512 packages(packages);
513
514 // version
515 md.version().ifPresent(this::version);
516
517 // main class
518 md.mainClass().ifPresent(this::mainClass);
519
520 // hashes
521 JLMA.hashes(md).ifPresent(mh -> {
522 algorithm(mh.algorithm());
523 mh.names().forEach(mn -> moduleHash(mn, mh.hashFor(mn)));
524 });
525
526 putModuleDescriptor();
527 }
528
529 void newBuilder() {
530 mv.visitTypeInsn(NEW, MODULE_DESCRIPTOR_BUILDER);
531 mv.visitInsn(DUP);
532 mv.visitLdcInsn(md.name());
533 mv.visitMethodInsn(INVOKESPECIAL, MODULE_DESCRIPTOR_BUILDER,
534 "<init>", "(Ljava/lang/String;)V", false);
535 mv.visitVarInsn(ASTORE, BUILDER_VAR);
536 mv.visitVarInsn(ALOAD, BUILDER_VAR);
537
538 if (md.isOpen()) {
539 setModuleBit("open", true);
540 }
541 if (md.isSynthetic()) {
542 setModuleBit("synthetic", true);
543 }
544 }
545
827
828 // must exist
829 Integer index = modulesToHashIndex.get(name);
830 if (index != null) {
831 mv.visitFieldInsn(GETSTATIC, CLASSNAME, MODULES_TO_HASH, "[[B");
832 pushInt(index);
833 mv.visitInsn(AALOAD);
834 assert(Objects.equals(hash, modulesToHash.get(name)));
835 } else {
836 pushInt(hash.length);
837 mv.visitIntInsn(NEWARRAY, T_BYTE);
838 for (int i = 0; i < hash.length; i++) {
839 mv.visitInsn(DUP); // arrayref
840 pushInt(i);
841 mv.visitIntInsn(BIPUSH, hash[i]);
842 mv.visitInsn(BASTORE);
843 }
844 }
845 mv.visitMethodInsn(INVOKEVIRTUAL, MODULE_DESCRIPTOR_BUILDER,
846 "moduleHash", STRING_BYTE_ARRAY_SIG, false);
847 mv.visitInsn(POP);
848 }
849 }
850
851 /*
852 * Wraps set creation, ensuring identical sets are properly deduplicated.
853 */
854 class DedupSetBuilder {
855 // map Set<String> to a specialized builder to allow them to be
856 // deduplicated as they are requested
857 final Map<Set<String>, SetBuilder<String>> stringSets = new HashMap<>();
858
859 // map Set<Requires.Modifier> to a specialized builder to allow them to be
860 // deduplicated as they are requested
861 final Map<Set<Requires.Modifier>, EnumSetBuilder<Requires.Modifier>>
862 requiresModifiersSets = new HashMap<>();
863
864 // map Set<Exports.Modifier> to a specialized builder to allow them to be
865 // deduplicated as they are requested
866 final Map<Set<Exports.Modifier>, EnumSetBuilder<Exports.Modifier>>
|
29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.lang.module.ModuleDescriptor;
32 import java.lang.module.ModuleDescriptor.*;
33 import java.util.ArrayList;
34 import java.util.Collection;
35 import java.util.EnumSet;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Objects;
41 import java.util.Set;
42 import java.util.function.IntSupplier;
43
44 import jdk.internal.misc.JavaLangModuleAccess;
45 import jdk.internal.misc.SharedSecrets;
46 import jdk.internal.module.Checks;
47 import jdk.internal.module.ModuleInfoExtender;
48 import jdk.internal.module.SystemModules;
49 import jdk.internal.module.WarnIfResolvedReason;
50 import jdk.internal.org.objectweb.asm.ClassWriter;
51 import jdk.internal.org.objectweb.asm.MethodVisitor;
52 import jdk.internal.org.objectweb.asm.Opcodes;
53
54 import static jdk.internal.org.objectweb.asm.Opcodes.*;
55
56 import jdk.tools.jlink.plugin.PluginException;
57 import jdk.tools.jlink.plugin.ResourcePool;
58 import jdk.tools.jlink.plugin.Plugin;
59 import jdk.tools.jlink.internal.plugins.SystemModuleDescriptorPlugin.SystemModulesClassGenerator.*;
60 import jdk.tools.jlink.plugin.ResourcePoolBuilder;
61 import jdk.tools.jlink.plugin.ResourcePoolEntry;
62
63 /**
64 * Jlink plugin to reconstitute module descriptors for system modules.
65 * It will extend module-info.class with Packages attribute,
66 * if not present. It also determines the number of packages of
67 * the boot layer at link time.
68 *
69 * This plugin will override jdk.internal.module.SystemModules class
507 uses(md.uses());
508
509 // provides
510 provides(md.provides());
511
512 // all packages
513 packages(packages);
514
515 // version
516 md.version().ifPresent(this::version);
517
518 // main class
519 md.mainClass().ifPresent(this::mainClass);
520
521 // hashes
522 JLMA.hashes(md).ifPresent(mh -> {
523 algorithm(mh.algorithm());
524 mh.names().forEach(mn -> moduleHash(mn, mh.hashFor(mn)));
525 });
526
527 // DO_NOT_RESOLVE_BY_DEFAULT
528 if (JLMA.doNotResolveByDefault(md)) {
529 setModuleBit("doNotResolveByDefault", true);
530 }
531
532 // WARN_IF_RESOLVED reason
533 if (JLMA.warnIfResolvedReason(md) != WarnIfResolvedReason.NONE)
534 warnIfResolved(JLMA.warnIfResolvedReason(md));
535 putModuleDescriptor();
536 }
537
538 void newBuilder() {
539 mv.visitTypeInsn(NEW, MODULE_DESCRIPTOR_BUILDER);
540 mv.visitInsn(DUP);
541 mv.visitLdcInsn(md.name());
542 mv.visitMethodInsn(INVOKESPECIAL, MODULE_DESCRIPTOR_BUILDER,
543 "<init>", "(Ljava/lang/String;)V", false);
544 mv.visitVarInsn(ASTORE, BUILDER_VAR);
545 mv.visitVarInsn(ALOAD, BUILDER_VAR);
546
547 if (md.isOpen()) {
548 setModuleBit("open", true);
549 }
550 if (md.isSynthetic()) {
551 setModuleBit("synthetic", true);
552 }
553 }
554
836
837 // must exist
838 Integer index = modulesToHashIndex.get(name);
839 if (index != null) {
840 mv.visitFieldInsn(GETSTATIC, CLASSNAME, MODULES_TO_HASH, "[[B");
841 pushInt(index);
842 mv.visitInsn(AALOAD);
843 assert(Objects.equals(hash, modulesToHash.get(name)));
844 } else {
845 pushInt(hash.length);
846 mv.visitIntInsn(NEWARRAY, T_BYTE);
847 for (int i = 0; i < hash.length; i++) {
848 mv.visitInsn(DUP); // arrayref
849 pushInt(i);
850 mv.visitIntInsn(BIPUSH, hash[i]);
851 mv.visitInsn(BASTORE);
852 }
853 }
854 mv.visitMethodInsn(INVOKEVIRTUAL, MODULE_DESCRIPTOR_BUILDER,
855 "moduleHash", STRING_BYTE_ARRAY_SIG, false);
856 mv.visitInsn(POP);
857 }
858
859 static final String WARN_IF_RESOLVED_REASON_CLASSNAME =
860 "jdk/internal/module/WarnIfResolvedReason";
861 static final String WARN_IF_RESOLVED_REASON_TYPE =
862 "Ljdk/internal/module/WarnIfResolvedReason;";
863 static final String WARN_METHOD_SIG =
864 "(" + WARN_IF_RESOLVED_REASON_TYPE + ")" + BUILDER_TYPE;
865
866 /*
867 * Invoke Builder.warnIfResolved(WarnIfResolvedReason reason)
868 */
869 void warnIfResolved(WarnIfResolvedReason reason) {
870 mv.visitVarInsn(ALOAD, BUILDER_VAR);
871 mv.visitFieldInsn(GETSTATIC,
872 WARN_IF_RESOLVED_REASON_CLASSNAME,
873 reason.name(),
874 WARN_IF_RESOLVED_REASON_TYPE);
875 mv.visitMethodInsn(INVOKEVIRTUAL,
876 MODULE_DESCRIPTOR_BUILDER,
877 "warnIfResolved",
878 WARN_METHOD_SIG,
879 false);
880 mv.visitInsn(POP);
881 }
882 }
883
884 /*
885 * Wraps set creation, ensuring identical sets are properly deduplicated.
886 */
887 class DedupSetBuilder {
888 // map Set<String> to a specialized builder to allow them to be
889 // deduplicated as they are requested
890 final Map<Set<String>, SetBuilder<String>> stringSets = new HashMap<>();
891
892 // map Set<Requires.Modifier> to a specialized builder to allow them to be
893 // deduplicated as they are requested
894 final Map<Set<Requires.Modifier>, EnumSetBuilder<Requires.Modifier>>
895 requiresModifiersSets = new HashMap<>();
896
897 // map Set<Exports.Modifier> to a specialized builder to allow them to be
898 // deduplicated as they are requested
899 final Map<Set<Exports.Modifier>, EnumSetBuilder<Exports.Modifier>>
|