< prev index next >

src/hotspot/share/classfile/systemDictionaryShared.hpp

Print this page

 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
 26 #define SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
 27 
 28 #include "cds/cds_globals.hpp"
 29 #include "cds/dumpTimeClassInfo.hpp"
 30 #include "cds/filemap.hpp"
 31 #include "cds/runTimeClassInfo.hpp"
 32 #include "classfile/classLoaderData.hpp"
 33 #include "classfile/packageEntry.hpp"
 34 #include "classfile/systemDictionary.hpp"
 35 #include "oops/klass.hpp"
 36 #include "oops/oopHandle.hpp"

 37 
 38 
 39 /*===============================================================================
 40 
 41     Handling of the classes in the AppCDS archive
 42 
 43     To ensure safety and to simplify the implementation, archived classes are
 44     "segregated" into 2 types. The following rules describe how they
 45     are stored and looked up.
 46 
 47 [1] Category of archived classes
 48 
 49     There are 2 disjoint groups of classes stored in the AppCDS archive:
 50 
 51     BUILTIN:              These classes may be defined ONLY by the BOOT/PLATFORM/APP
 52                           loaders.
 53 
 54     UNREGISTERED:         These classes may be defined ONLY by a ClassLoader
 55                           instance that's not listed above (using fingerprint matching)
 56 

134   }
135 };
136 
137 class SystemDictionaryShared: public SystemDictionary {
138   friend class LambdaProxyClassDictionary;
139 
140   struct ArchiveInfo {
141     RunTimeSharedDictionary _builtin_dictionary;
142     RunTimeSharedDictionary _unregistered_dictionary;
143 
144     void print_on(const char* prefix, outputStream* st, bool is_static_archive);
145     void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive);
146   };
147 
148 private:
149   class ExclusionCheckCandidates;
150   static DumpTimeSharedClassTable* _dumptime_table;
151 
152   static ArchiveInfo _static_archive;
153   static ArchiveInfo _dynamic_archive;

154 
155   static ArchiveInfo* get_archive(bool is_static_archive) {
156     return is_static_archive ? &_static_archive : &_dynamic_archive;
157   }
158 
159   static InstanceKlass* load_shared_class_for_builtin_loader(
160                                                Symbol* class_name,
161                                                Handle class_loader,
162                                                TRAPS);
163   static InstanceKlass* acquire_class_for_current_thread(
164                                  InstanceKlass *ik,
165                                  Handle class_loader,
166                                  Handle protection_domain,
167                                  const ClassFileStream* cfs,
168                                  TRAPS);
169 
170   // Guaranteed to return non-null value for non-shared classes.
171   // k must not be a shared class.
172   static DumpTimeClassInfo* get_info(InstanceKlass* k);
173   static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
174 
175   static void write_dictionary(RunTimeSharedDictionary* dictionary,
176                                bool is_builtin);
177   static bool is_jfr_event_class(InstanceKlass *k);
178   static bool should_be_excluded_impl(InstanceKlass* k, DumpTimeClassInfo* info);
179 
180   // exclusion checks
181   static void check_exclusion_for_self_and_dependencies(InstanceKlass *k);
182   static bool check_self_exclusion(InstanceKlass* k);
183   static const char* check_self_exclusion_helper(InstanceKlass* k, bool& log_warning);
184   static bool check_dependencies_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
185   static bool check_verification_constraint_exclusion(InstanceKlass* k, Symbol* constraint_class_name);
186   static bool is_dependency_excluded(InstanceKlass* k, InstanceKlass* dependency, const char* type);
187   static bool is_excluded_verification_constraint(InstanceKlass* k, Symbol* constraint_class_name);
188   static Klass* find_verification_constraint_bottom_class(InstanceKlass* k, Symbol* constraint_class_name);
189 
190   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
191   static bool has_been_redefined(InstanceKlass* k);
192   DEBUG_ONLY(static bool _class_loading_may_happen;)
193 
194   static void copy_verification_info_from_preimage(InstanceKlass* klass);
195   static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
196 
197   template<typename Function>
198   static void iterate_verification_constraint_names(InstanceKlass* k, DumpTimeClassInfo* info, Function func);
199 
200 public:










201   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
202   static bool has_archived_enum_objs(InstanceKlass* ik);
203   static void set_has_archived_enum_objs(InstanceKlass* ik);
204 
205   static InstanceKlass* find_builtin_class(Symbol* class_name);
206 
207   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
208                                                    RunTimeSharedDictionary* dynamic_dict,
209                                                    Symbol* name);
210 
211   static bool has_platform_or_app_classes();
212 
213   // Called by PLATFORM/APP loader only
214   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
215                                                Handle class_loader,
216                                                TRAPS);
217 
218 
219   static void allocate_shared_data_arrays(int size, TRAPS);
220 
221   static bool is_builtin_loader(ClassLoaderData* loader_data);
222 
223   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
224                                                             Symbol* super_name,  bool is_superclass);
225 
226   static void initialize() NOT_CDS_RETURN;
227   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
228   static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
229   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
230 




231   static Dictionary* boot_loader_dictionary() {
232     return ClassLoaderData::the_null_class_loader_data()->dictionary();
233   }
234 
235   static void update_shared_entry(InstanceKlass* klass, int id);
236   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
237 
238   static InstanceKlass* lookup_from_stream(Symbol* class_name,
239                                            Handle class_loader,
240                                            Handle protection_domain,
241                                            const ClassFileStream* st,
242                                            TRAPS);
243   // "verification_constraints" are a set of checks performed by
244   // VerificationType::is_reference_assignable_from when verifying a shared class during
245   // dump time.
246   //
247   // With AppCDS, it is possible to override archived classes by calling
248   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
249   // ensures that you cannot load a shared class if its super type(s) are changed. However,
250   // we need an additional check to ensure that the verification_constraints did not change

253                   Symbol* from_name, bool from_field_is_protected,
254                   bool from_is_array, bool from_is_object,
255                   bool* skip_assignability_check);
256   static void add_old_verification_constraint(Thread* current, InstanceKlass* k, Symbol* name);
257   static void check_verification_constraints(InstanceKlass* klass,
258                                              TRAPS) NOT_CDS_RETURN;
259   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
260   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
261   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
262   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
263   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
264                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
265   static bool is_builtin(const InstanceKlass* k) {
266     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
267   }
268   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
269   static InstanceKlass* get_unregistered_class(Symbol* name);
270   static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
271 
272   static void finish_exclusion_checks();
273   static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
274 
275   static bool should_be_excluded(Klass* k);
276   static void validate_before_archiving(InstanceKlass* k);
277   static bool is_excluded_class(InstanceKlass* k);
278   static void set_excluded(InstanceKlass* k);
279   static void set_excluded_locked(InstanceKlass* k);
280   static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
281   static void log_exclusion(InstanceKlass* k, const char* reason, bool is_warning = false);
282   static void dumptime_classes_do(class MetaspaceClosure* it);
283   static void write_to_archive(bool is_static_archive = true);
284   static void serialize_dictionary_headers(class SerializeClosure* soc,
285                                            bool is_static_archive = true);
286   static void serialize_vm_classes(class SerializeClosure* soc);
287   static const char* loader_type_for_shared_class(Klass* k);
288   static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes);
289   static void print() { return print_on(tty); }
290   static void print_on(outputStream* st) NOT_CDS_RETURN;
291   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
292   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
293   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);

301   public:
302     NoClassLoadingMark() {
303       assert(_class_loading_may_happen, "must not be nested");
304       _class_loading_may_happen = false;
305     }
306     ~NoClassLoadingMark() {
307       _class_loading_may_happen = true;
308     }
309   };
310 #endif
311 
312   template <typename T>
313   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
314     assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be");
315     assert(ptr > (T*)SharedBaseAddress, "must be");
316     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
317     return primitive_hash<uintx>(offset);
318   }
319 
320   static unsigned int hash_for_shared_dictionary(address ptr);

321 };
322 
323 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP

 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
 26 #define SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
 27 
 28 #include "cds/cds_globals.hpp"
 29 #include "cds/dumpTimeClassInfo.hpp"
 30 #include "cds/filemap.hpp"
 31 #include "cds/runTimeClassInfo.hpp"
 32 #include "classfile/classLoaderData.hpp"
 33 #include "classfile/packageEntry.hpp"
 34 #include "classfile/systemDictionary.hpp"
 35 #include "oops/klass.hpp"
 36 #include "oops/oopHandle.hpp"
 37 #include "oops/trainingData.hpp"
 38 
 39 
 40 /*===============================================================================
 41 
 42     Handling of the classes in the AppCDS archive
 43 
 44     To ensure safety and to simplify the implementation, archived classes are
 45     "segregated" into 2 types. The following rules describe how they
 46     are stored and looked up.
 47 
 48 [1] Category of archived classes
 49 
 50     There are 2 disjoint groups of classes stored in the AppCDS archive:
 51 
 52     BUILTIN:              These classes may be defined ONLY by the BOOT/PLATFORM/APP
 53                           loaders.
 54 
 55     UNREGISTERED:         These classes may be defined ONLY by a ClassLoader
 56                           instance that's not listed above (using fingerprint matching)
 57 

135   }
136 };
137 
138 class SystemDictionaryShared: public SystemDictionary {
139   friend class LambdaProxyClassDictionary;
140 
141   struct ArchiveInfo {
142     RunTimeSharedDictionary _builtin_dictionary;
143     RunTimeSharedDictionary _unregistered_dictionary;
144 
145     void print_on(const char* prefix, outputStream* st, bool is_static_archive);
146     void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive);
147   };
148 
149 private:
150   class ExclusionCheckCandidates;
151   static DumpTimeSharedClassTable* _dumptime_table;
152 
153   static ArchiveInfo _static_archive;
154   static ArchiveInfo _dynamic_archive;
155   static bool _finished_exclusion_checks;
156 
157   static ArchiveInfo* get_archive(bool is_static_archive) {
158     return is_static_archive ? &_static_archive : &_dynamic_archive;
159   }
160 
161   static InstanceKlass* load_shared_class_for_builtin_loader(
162                                                Symbol* class_name,
163                                                Handle class_loader,
164                                                TRAPS);
165   static InstanceKlass* acquire_class_for_current_thread(
166                                  InstanceKlass *ik,
167                                  Handle class_loader,
168                                  Handle protection_domain,
169                                  const ClassFileStream* cfs,
170                                  TRAPS);
171 




172 
173   static void write_dictionary(RunTimeSharedDictionary* dictionary,
174                                bool is_builtin);

175   static bool should_be_excluded_impl(InstanceKlass* k, DumpTimeClassInfo* info);
176 
177   // exclusion checks
178   static void check_exclusion_for_self_and_dependencies(InstanceKlass *k);
179   static bool check_self_exclusion(InstanceKlass* k);
180   static const char* check_self_exclusion_helper(InstanceKlass* k, bool& log_warning);
181   static bool check_dependencies_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
182   static bool check_verification_constraint_exclusion(InstanceKlass* k, Symbol* constraint_class_name);
183   static bool is_dependency_excluded(InstanceKlass* k, InstanceKlass* dependency, const char* type);
184   static bool is_excluded_verification_constraint(InstanceKlass* k, Symbol* constraint_class_name);
185   static Klass* find_verification_constraint_bottom_class(InstanceKlass* k, Symbol* constraint_class_name);
186 
187   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;

188   DEBUG_ONLY(static bool _class_loading_may_happen;)
189 
190   static void copy_verification_info_from_preimage(InstanceKlass* klass);
191   static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
192 
193   template<typename Function>
194   static void iterate_verification_constraint_names(InstanceKlass* k, DumpTimeClassInfo* info, Function func);
195 
196 public:
197   // Guaranteed to return non-null value for non-shared classes.
198   // k must not be a shared class.
199   static DumpTimeClassInfo* get_info(InstanceKlass* k);
200   static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
201   static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
202 
203   static bool should_hidden_class_be_archived(InstanceKlass* k);
204   static void mark_required_hidden_class(InstanceKlass* k);
205   static bool has_been_redefined(InstanceKlass* k);
206   static bool is_jfr_event_class(InstanceKlass *k);
207   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
208   static bool has_archived_enum_objs(InstanceKlass* ik);
209   static void set_has_archived_enum_objs(InstanceKlass* ik);
210 
211   static InstanceKlass* find_builtin_class(Symbol* class_name);
212 
213   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
214                                                    RunTimeSharedDictionary* dynamic_dict,
215                                                    Symbol* name);
216 
217   static bool has_platform_or_app_classes();
218 
219   // Called by PLATFORM/APP loader only
220   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
221                                                Handle class_loader,
222                                                TRAPS);
223 
224 
225   static void allocate_shared_data_arrays(int size, TRAPS);
226 
227   static bool is_builtin_loader(ClassLoaderData* loader_data);
228 
229   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
230                                                             Symbol* super_name,  bool is_superclass);
231 
232   static void initialize() NOT_CDS_RETURN;
233   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
234   static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
235   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
236 
237   static bool can_be_preinited(InstanceKlass* ik);
238   static bool can_be_preinited_locked(InstanceKlass* ik);
239   static void reset_preinit_check();
240 
241   static Dictionary* boot_loader_dictionary() {
242     return ClassLoaderData::the_null_class_loader_data()->dictionary();
243   }
244 
245   static void update_shared_entry(InstanceKlass* klass, int id);
246   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
247 
248   static InstanceKlass* lookup_from_stream(Symbol* class_name,
249                                            Handle class_loader,
250                                            Handle protection_domain,
251                                            const ClassFileStream* st,
252                                            TRAPS);
253   // "verification_constraints" are a set of checks performed by
254   // VerificationType::is_reference_assignable_from when verifying a shared class during
255   // dump time.
256   //
257   // With AppCDS, it is possible to override archived classes by calling
258   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
259   // ensures that you cannot load a shared class if its super type(s) are changed. However,
260   // we need an additional check to ensure that the verification_constraints did not change

263                   Symbol* from_name, bool from_field_is_protected,
264                   bool from_is_array, bool from_is_object,
265                   bool* skip_assignability_check);
266   static void add_old_verification_constraint(Thread* current, InstanceKlass* k, Symbol* name);
267   static void check_verification_constraints(InstanceKlass* klass,
268                                              TRAPS) NOT_CDS_RETURN;
269   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
270   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
271   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
272   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
273   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
274                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
275   static bool is_builtin(const InstanceKlass* k) {
276     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
277   }
278   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
279   static InstanceKlass* get_unregistered_class(Symbol* name);
280   static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
281 
282   static void finish_exclusion_checks();

283 
284   static bool should_be_excluded(Klass* k);
285   static void validate_before_archiving(InstanceKlass* k);
286   static bool is_excluded_class(InstanceKlass* k);
287   static void set_excluded(InstanceKlass* k);
288   static void set_excluded_locked(InstanceKlass* k);
289   static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
290   static void log_exclusion(InstanceKlass* k, const char* reason, bool is_warning = false);
291   static void dumptime_classes_do(class MetaspaceClosure* it);
292   static void write_to_archive(bool is_static_archive = true);
293   static void serialize_dictionary_headers(class SerializeClosure* soc,
294                                            bool is_static_archive = true);
295   static void serialize_vm_classes(class SerializeClosure* soc);
296   static const char* loader_type_for_shared_class(Klass* k);
297   static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes);
298   static void print() { return print_on(tty); }
299   static void print_on(outputStream* st) NOT_CDS_RETURN;
300   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
301   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
302   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);

310   public:
311     NoClassLoadingMark() {
312       assert(_class_loading_may_happen, "must not be nested");
313       _class_loading_may_happen = false;
314     }
315     ~NoClassLoadingMark() {
316       _class_loading_may_happen = true;
317     }
318   };
319 #endif
320 
321   template <typename T>
322   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
323     assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be");
324     assert(ptr > (T*)SharedBaseAddress, "must be");
325     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
326     return primitive_hash<uintx>(offset);
327   }
328 
329   static unsigned int hash_for_shared_dictionary(address ptr);
330   static void create_loader_positive_lookup_cache(TRAPS);
331 };
332 
333 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
< prev index next >