39 // Name of the resource containing mapping from module names to defining class loader type
40 #define MODULE_LOADER_MAP "jdk/internal/vm/cds/resources/ModuleLoaderMap.dat"
41
42 // Initial sizes of the following arrays are based on the generated ModuleLoaderMap.dat
43 #define INITIAL_BOOT_MODULES_ARRAY_SIZE 30
44 #define INITIAL_PLATFORM_MODULES_ARRAY_SIZE 15
45
46 // Class path entry (directory or zip file)
47
48 class JImageFile;
49 class ClassFileStream;
50
51 class ClassPathEntry : public CHeapObj<mtClass> {
52 private:
53 ClassPathEntry* volatile _next;
54 public:
55 // Next entry in class path
56 ClassPathEntry* next() const {
57 return (ClassPathEntry*) OrderAccess::load_ptr_acquire(&_next);
58 }
59 void set_next(ClassPathEntry* next) {
60 // may have unlocked readers, so ensure visibility.
61 OrderAccess::release_store_ptr(&_next, next);
62 }
63 virtual bool is_jrt() = 0;
64 virtual bool is_jar_file() const = 0;
65 virtual const char* name() const = 0;
66 virtual JImageFile* jimage() const = 0;
67 // Constructor
68 ClassPathEntry() : _next(NULL) {}
69 // Attempt to locate file_name through this class path entry.
70 // Returns a class file parsing stream if successfull.
71 virtual ClassFileStream* open_stream(const char* name, TRAPS) = 0;
72 // Debugging
73 NOT_PRODUCT(virtual void compile_the_world(Handle loader, TRAPS) = 0;)
74 };
75
76 class ClassPathDirEntry: public ClassPathEntry {
77 private:
78 const char* _dir; // Name of directory
79 public:
80 bool is_jrt() { return false; }
81 bool is_jar_file() const { return false; }
82 const char* name() const { return _dir; }
83 JImageFile* jimage() const { return NULL; }
84 ClassPathDirEntry(const char* dir);
85 ClassFileStream* open_stream(const char* name, TRAPS);
86 // Debugging
87 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
88 };
89
90
91 // Type definitions for zip file and zip file entry
92 typedef void* jzfile;
93 typedef struct {
94 char *name; /* entry name */
95 jlong time; /* modification time */
96 jlong size; /* size of uncompressed data */
97 jlong csize; /* size of compressed data (zero if uncompressed) */
98 jint crc; /* crc of uncompressed data */
99 char *comment; /* optional zip file comment */
100 jbyte *extra; /* optional extra data */
101 jlong pos; /* position of LOC header (if negative) or data */
102 } jzentry;
103
104
105 class ClassPathZipEntry: public ClassPathEntry {
106 enum {
107 _unknown = 0,
108 _yes = 1,
109 _no = 2
110 };
111 private:
112 jzfile* _zip; // The zip archive
113 const char* _zip_name; // Name of zip archive
114 bool _is_boot_append; // entry coming from -Xbootclasspath/a
115 u1 _multi_versioned; // indicates if the jar file has multi-versioned entries.
116 // It can have value of "_unknown", "_yes", or "_no"
117 public:
118 bool is_jrt() { return false; }
119 bool is_jar_file() const { return true; }
120 const char* name() const { return _zip_name; }
121 JImageFile* jimage() const { return NULL; }
122 ClassPathZipEntry(jzfile* zip, const char* zip_name, bool is_boot_append);
123 ~ClassPathZipEntry();
124 u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS);
125 u1* open_versioned_entry(const char* name, jint* filesize, TRAPS) NOT_CDS_RETURN_(NULL);
126 ClassFileStream* open_stream(const char* name, TRAPS);
127 void contents_do(void f(const char* name, void* context), void* context);
128 bool is_multiple_versioned(TRAPS) NOT_CDS_RETURN_(false);
129 // Debugging
130 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
131 };
132
133
134 // For java image files
135 class ClassPathImageEntry: public ClassPathEntry {
136 private:
137 JImageFile* _jimage;
138 const char* _name;
139 public:
140 bool is_jrt();
141 bool is_jar_file() const { return false; }
142 bool is_open() const { return _jimage != NULL; }
143 const char* name() const { return _name == NULL ? "" : _name; }
144 JImageFile* jimage() const { return _jimage; }
145 ClassPathImageEntry(JImageFile* jimage, const char* name);
146 ~ClassPathImageEntry();
147 ClassFileStream* open_stream(const char* name, TRAPS);
148
149 // Debugging
150 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
151 };
152
153 // ModuleClassPathList contains a linked list of ClassPathEntry's
154 // that have been specified for a specific module. Currently,
155 // the only way to specify a module/path pair is via the --patch-module
156 // command line option.
157 class ModuleClassPathList : public CHeapObj<mtClass> {
158 private:
159 Symbol* _module_name;
160 // First and last entries of class path entries for a specific module
161 ClassPathEntry* _module_first_entry;
162 ClassPathEntry* _module_last_entry;
163 public:
164 Symbol* module_name() const { return _module_name; }
165 ClassPathEntry* module_first_entry() const { return _module_first_entry; }
166 ModuleClassPathList(Symbol* module_name);
|
39 // Name of the resource containing mapping from module names to defining class loader type
40 #define MODULE_LOADER_MAP "jdk/internal/vm/cds/resources/ModuleLoaderMap.dat"
41
42 // Initial sizes of the following arrays are based on the generated ModuleLoaderMap.dat
43 #define INITIAL_BOOT_MODULES_ARRAY_SIZE 30
44 #define INITIAL_PLATFORM_MODULES_ARRAY_SIZE 15
45
46 // Class path entry (directory or zip file)
47
48 class JImageFile;
49 class ClassFileStream;
50
51 class ClassPathEntry : public CHeapObj<mtClass> {
52 private:
53 ClassPathEntry* volatile _next;
54 public:
55 // Next entry in class path
56 ClassPathEntry* next() const {
57 return (ClassPathEntry*) OrderAccess::load_ptr_acquire(&_next);
58 }
59 virtual ~ClassPathEntry() {}
60 void set_next(ClassPathEntry* next) {
61 // may have unlocked readers, so ensure visibility.
62 OrderAccess::release_store_ptr(&_next, next);
63 }
64 virtual bool is_jrt() = 0;
65 virtual bool is_jar_file() const = 0;
66 virtual const char* name() const = 0;
67 virtual JImageFile* jimage() const = 0;
68 // Constructor
69 ClassPathEntry() : _next(NULL) {}
70 // Attempt to locate file_name through this class path entry.
71 // Returns a class file parsing stream if successfull.
72 virtual ClassFileStream* open_stream(const char* name, TRAPS) = 0;
73 // Debugging
74 NOT_PRODUCT(virtual void compile_the_world(Handle loader, TRAPS) = 0;)
75 };
76
77 class ClassPathDirEntry: public ClassPathEntry {
78 private:
79 const char* _dir; // Name of directory
80 public:
81 bool is_jrt() { return false; }
82 bool is_jar_file() const { return false; }
83 const char* name() const { return _dir; }
84 JImageFile* jimage() const { return NULL; }
85 ClassPathDirEntry(const char* dir);
86 virtual ~ClassPathDirEntry() {}
87 ClassFileStream* open_stream(const char* name, TRAPS);
88 // Debugging
89 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
90 };
91
92
93 // Type definitions for zip file and zip file entry
94 typedef void* jzfile;
95 typedef struct {
96 char *name; /* entry name */
97 jlong time; /* modification time */
98 jlong size; /* size of uncompressed data */
99 jlong csize; /* size of compressed data (zero if uncompressed) */
100 jint crc; /* crc of uncompressed data */
101 char *comment; /* optional zip file comment */
102 jbyte *extra; /* optional extra data */
103 jlong pos; /* position of LOC header (if negative) or data */
104 } jzentry;
105
106
107 class ClassPathZipEntry: public ClassPathEntry {
108 enum {
109 _unknown = 0,
110 _yes = 1,
111 _no = 2
112 };
113 private:
114 jzfile* _zip; // The zip archive
115 const char* _zip_name; // Name of zip archive
116 bool _is_boot_append; // entry coming from -Xbootclasspath/a
117 u1 _multi_versioned; // indicates if the jar file has multi-versioned entries.
118 // It can have value of "_unknown", "_yes", or "_no"
119 public:
120 bool is_jrt() { return false; }
121 bool is_jar_file() const { return true; }
122 const char* name() const { return _zip_name; }
123 JImageFile* jimage() const { return NULL; }
124 ClassPathZipEntry(jzfile* zip, const char* zip_name, bool is_boot_append);
125 virtual ~ClassPathZipEntry();
126 u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS);
127 u1* open_versioned_entry(const char* name, jint* filesize, TRAPS) NOT_CDS_RETURN_(NULL);
128 ClassFileStream* open_stream(const char* name, TRAPS);
129 void contents_do(void f(const char* name, void* context), void* context);
130 bool is_multiple_versioned(TRAPS) NOT_CDS_RETURN_(false);
131 // Debugging
132 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
133 };
134
135
136 // For java image files
137 class ClassPathImageEntry: public ClassPathEntry {
138 private:
139 JImageFile* _jimage;
140 const char* _name;
141 public:
142 bool is_jrt();
143 bool is_jar_file() const { return false; }
144 bool is_open() const { return _jimage != NULL; }
145 const char* name() const { return _name == NULL ? "" : _name; }
146 JImageFile* jimage() const { return _jimage; }
147 ClassPathImageEntry(JImageFile* jimage, const char* name);
148 virtual ~ClassPathImageEntry();
149 ClassFileStream* open_stream(const char* name, TRAPS);
150
151 // Debugging
152 NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
153 };
154
155 // ModuleClassPathList contains a linked list of ClassPathEntry's
156 // that have been specified for a specific module. Currently,
157 // the only way to specify a module/path pair is via the --patch-module
158 // command line option.
159 class ModuleClassPathList : public CHeapObj<mtClass> {
160 private:
161 Symbol* _module_name;
162 // First and last entries of class path entries for a specific module
163 ClassPathEntry* _module_first_entry;
164 ClassPathEntry* _module_last_entry;
165 public:
166 Symbol* module_name() const { return _module_name; }
167 ClassPathEntry* module_first_entry() const { return _module_first_entry; }
168 ModuleClassPathList(Symbol* module_name);
|