< prev index next >

src/hotspot/share/classfile/systemDictionaryShared.hpp

Print this page

  1 /*
  2  * Copyright (c) 2014, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 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/filemap.hpp"
 30 #include "cds/dumpTimeClassInfo.hpp"
 31 #include "cds/lambdaProxyClassDictionary.hpp"

 32 #include "cds/runTimeClassInfo.hpp"
 33 #include "classfile/classLoaderData.hpp"
 34 #include "classfile/packageEntry.hpp"
 35 #include "classfile/systemDictionary.hpp"
 36 #include "oops/klass.hpp"
 37 #include "oops/oopHandle.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 

127   SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
128   ~SharedClassLoadingMark() {
129     assert(THREAD != nullptr, "Current thread is nullptr");
130     assert(_klass != nullptr, "InstanceKlass is nullptr");
131     if (HAS_PENDING_EXCEPTION) {
132       if (_klass->is_shared()) {
133         _klass->set_shared_loading_failed();
134       }
135     }
136   }
137 };
138 
139 class SystemDictionaryShared: public SystemDictionary {
140   friend class ExcludeDumpTimeSharedClasses;
141   friend class CleanupDumpTimeLambdaProxyClassTable;
142 
143   struct ArchiveInfo {
144     RunTimeSharedDictionary _builtin_dictionary;
145     RunTimeSharedDictionary _unregistered_dictionary;
146     LambdaProxyClassDictionary _lambda_proxy_class_dictionary;

147 
148     const RunTimeLambdaProxyClassInfo* lookup_lambda_proxy_class(LambdaProxyClassKey* key) {
149       return _lambda_proxy_class_dictionary.lookup(key, key->hash(), 0);
150     }
151 





152     void print_on(const char* prefix, outputStream* st);
153     void print_table_statistics(const char* prefix, outputStream* st);
154   };
155 
156 public:
157   enum : char {
158     FROM_FIELD_IS_PROTECTED = 1 << 0,
159     FROM_IS_ARRAY           = 1 << 1,
160     FROM_IS_OBJECT          = 1 << 2
161   };
162 
163 private:
164 
165   static DumpTimeSharedClassTable* _dumptime_table;
166   static DumpTimeLambdaProxyClassDictionary* _dumptime_lambda_proxy_class_dictionary;
167 



168   static ArchiveInfo _static_archive;
169   static ArchiveInfo _dynamic_archive;
170 
171   static ArchiveInfo* get_archive(bool is_static_archive) {
172     return is_static_archive ? &_static_archive : &_dynamic_archive;
173   }
174 
175   static InstanceKlass* load_shared_class_for_builtin_loader(
176                                                Symbol* class_name,
177                                                Handle class_loader,
178                                                TRAPS);
179   static InstanceKlass* acquire_class_for_current_thread(
180                                  InstanceKlass *ik,
181                                  Handle class_loader,
182                                  Handle protection_domain,
183                                  const ClassFileStream* cfs,
184                                  TRAPS);
185 
186   // Guaranteed to return non-null value for non-shared classes.
187   // k must not be a shared class.
188   static DumpTimeClassInfo* get_info(InstanceKlass* k);
189   static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
190 
191   static void write_dictionary(RunTimeSharedDictionary* dictionary,
192                                bool is_builtin);
193   static void write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary* dictionary);

194   static void cleanup_lambda_proxy_class_dictionary();

195   static void reset_registered_lambda_proxy_class(InstanceKlass* ik);
196   static bool is_jfr_event_class(InstanceKlass *k);
197   static bool is_registered_lambda_proxy_class(InstanceKlass* ik);
198   static bool check_for_exclusion_impl(InstanceKlass* k);
199   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
200   static bool has_been_redefined(InstanceKlass* k);
201   static InstanceKlass* retrieve_lambda_proxy_class(const RunTimeLambdaProxyClassInfo* info) NOT_CDS_RETURN_(nullptr);
202 
203   DEBUG_ONLY(static bool _class_loading_may_happen;)
204 
205 public:


206   static bool is_hidden_lambda_proxy(InstanceKlass* ik);
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 handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
235 




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

266                                      InstanceKlass* lambda_ik,
267                                      Symbol* invoked_name,
268                                      Symbol* invoked_type,
269                                      Symbol* method_type,
270                                      Method* member_method,
271                                      Symbol* instantiated_method_type, TRAPS) NOT_CDS_RETURN;
272   static void add_to_dump_time_lambda_proxy_class_dictionary(LambdaProxyClassKey& key,
273                                                              InstanceKlass* proxy_klass) NOT_CDS_RETURN;
274   static InstanceKlass* get_shared_lambda_proxy_class(InstanceKlass* caller_ik,
275                                                       Symbol* invoked_name,
276                                                       Symbol* invoked_type,
277                                                       Symbol* method_type,
278                                                       Method* member_method,
279                                                       Symbol* instantiated_method_type) NOT_CDS_RETURN_(nullptr);
280   static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(nullptr);
281   static InstanceKlass* prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik,
282                                                           InstanceKlass* caller_ik, TRAPS) NOT_CDS_RETURN_(nullptr);
283   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
284   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
285                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
286   static bool is_builtin(InstanceKlass* k) {
287     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
288   }
289   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
290 
291   static void check_excluded_classes();
292   static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
293   static void validate_before_archiving(InstanceKlass* k);
294   static bool is_excluded_class(InstanceKlass* k);
295   static void set_excluded(InstanceKlass* k);
296   static void set_excluded_locked(InstanceKlass* k);
297   static bool warn_excluded(InstanceKlass* k, const char* reason);
298   static void dumptime_classes_do(class MetaspaceClosure* it);
299   static size_t estimate_size_for_archive();
300   static void write_to_archive(bool is_static_archive = true);
301   static void adjust_lambda_proxy_class_dictionary();



302   static void serialize_dictionary_headers(class SerializeClosure* soc,
303                                            bool is_static_archive = true);
304   static void serialize_vm_classes(class SerializeClosure* soc);
305   static void print() { return print_on(tty); }
306   static void print_on(outputStream* st) NOT_CDS_RETURN;
307   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
308   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
309   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
310   static bool is_supported_invokedynamic(BootstrapInfo* bsi) NOT_CDS_RETURN_(false);
311   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
312 
















313 #ifdef ASSERT
314   // This object marks a critical period when writing the CDS archive. During this
315   // period, the JVM must not load any new classes, so as to avoid adding new
316   // items in the SystemDictionaryShared::_dumptime_table.
317   class NoClassLoadingMark: public StackObj {
318   public:
319     NoClassLoadingMark() {
320       assert(_class_loading_may_happen, "must not be nested");
321       _class_loading_may_happen = false;
322     }
323     ~NoClassLoadingMark() {
324       _class_loading_may_happen = true;
325     }
326   };
327 #endif
328 
329   template <typename T>
330   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
331     assert(MetaspaceObj::is_shared((const MetaspaceObj*)ptr), "must be");
332     assert(ptr > (T*)SharedBaseAddress, "must be");
333     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
334     return primitive_hash<uintx>(offset);
335   }
336 
337   static unsigned int hash_for_shared_dictionary(address ptr);


338 };
339 
340 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP

  1 /*
  2  * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 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/filemap.hpp"
 30 #include "cds/dumpTimeClassInfo.hpp"
 31 #include "cds/lambdaProxyClassDictionary.hpp"
 32 #include "cds/methodDataDictionary.hpp"
 33 #include "cds/runTimeClassInfo.hpp"
 34 #include "classfile/classLoaderData.hpp"
 35 #include "classfile/packageEntry.hpp"
 36 #include "classfile/systemDictionary.hpp"
 37 #include "oops/klass.hpp"
 38 #include "oops/oopHandle.hpp"
 39 #include "oops/trainingData.hpp"
 40 
 41 
 42 /*===============================================================================
 43 
 44     Handling of the classes in the AppCDS archive
 45 
 46     To ensure safety and to simplify the implementation, archived classes are
 47     "segregated" into 2 types. The following rules describe how they
 48     are stored and looked up.
 49 
 50 [1] Category of archived classes
 51 
 52     There are 2 disjoint groups of classes stored in the AppCDS archive:
 53 
 54     BUILTIN:              These classes may be defined ONLY by the BOOT/PLATFORM/APP
 55                           loaders.
 56 
 57     UNREGISTERED:         These classes may be defined ONLY by a ClassLoader
 58                           instance that's not listed above (using fingerprint matching)
 59 

129   SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
130   ~SharedClassLoadingMark() {
131     assert(THREAD != nullptr, "Current thread is nullptr");
132     assert(_klass != nullptr, "InstanceKlass is nullptr");
133     if (HAS_PENDING_EXCEPTION) {
134       if (_klass->is_shared()) {
135         _klass->set_shared_loading_failed();
136       }
137     }
138   }
139 };
140 
141 class SystemDictionaryShared: public SystemDictionary {
142   friend class ExcludeDumpTimeSharedClasses;
143   friend class CleanupDumpTimeLambdaProxyClassTable;
144 
145   struct ArchiveInfo {
146     RunTimeSharedDictionary _builtin_dictionary;
147     RunTimeSharedDictionary _unregistered_dictionary;
148     LambdaProxyClassDictionary _lambda_proxy_class_dictionary;
149     MethodDataInfoDictionary _method_info_dictionary;
150 
151     const RunTimeLambdaProxyClassInfo* lookup_lambda_proxy_class(LambdaProxyClassKey* key) {
152       return _lambda_proxy_class_dictionary.lookup(key, key->hash(), 0);
153     }
154 
155     const RunTimeMethodDataInfo* lookup_method_info(Method* m) {
156       MethodDataKey key(m);
157       return _method_info_dictionary.lookup(&key, key.hash(), 0);
158     }
159 
160     void print_on(const char* prefix, outputStream* st);
161     void print_table_statistics(const char* prefix, outputStream* st);
162   };
163 
164 public:
165   enum : char {
166     FROM_FIELD_IS_PROTECTED = 1 << 0,
167     FROM_IS_ARRAY           = 1 << 1,
168     FROM_IS_OBJECT          = 1 << 2
169   };
170 
171 private:
172 
173   static DumpTimeSharedClassTable* _dumptime_table;
174   static DumpTimeLambdaProxyClassDictionary* _dumptime_lambda_proxy_class_dictionary;
175 
176   static DumpTimeMethodInfoDictionary* _dumptime_method_info_dictionary;
177   static DumpTimeMethodInfoDictionary* _cloned_dumptime_method_info_dictionary;
178 
179   static ArchiveInfo _static_archive;
180   static ArchiveInfo _dynamic_archive;
181 
182   static ArchiveInfo* get_archive(bool is_static_archive) {
183     return is_static_archive ? &_static_archive : &_dynamic_archive;
184   }
185 
186   static InstanceKlass* load_shared_class_for_builtin_loader(
187                                                Symbol* class_name,
188                                                Handle class_loader,
189                                                TRAPS);
190   static InstanceKlass* acquire_class_for_current_thread(
191                                  InstanceKlass *ik,
192                                  Handle class_loader,
193                                  Handle protection_domain,
194                                  const ClassFileStream* cfs,
195                                  TRAPS);
196 
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 
202   static void write_dictionary(RunTimeSharedDictionary* dictionary,
203                                bool is_builtin);
204   static void write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary* dictionary);
205   static void write_method_info_dictionary(MethodDataInfoDictionary* dictionary);
206   static void cleanup_lambda_proxy_class_dictionary();
207   static void cleanup_method_info_dictionary();
208   static void reset_registered_lambda_proxy_class(InstanceKlass* ik);

209   static bool is_registered_lambda_proxy_class(InstanceKlass* ik);
210   static bool check_for_exclusion_impl(InstanceKlass* k);
211   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;

212   static InstanceKlass* retrieve_lambda_proxy_class(const RunTimeLambdaProxyClassInfo* info) NOT_CDS_RETURN_(nullptr);
213 
214   DEBUG_ONLY(static bool _class_loading_may_happen;)
215 
216 public:
217   static bool has_been_redefined(InstanceKlass* k);
218   static bool is_jfr_event_class(InstanceKlass *k);
219   static bool is_hidden_lambda_proxy(InstanceKlass* ik);
220   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
221   static bool has_archived_enum_objs(InstanceKlass* ik);
222   static void set_has_archived_enum_objs(InstanceKlass* ik);
223 
224   static InstanceKlass* find_builtin_class(Symbol* class_name);
225 
226   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
227                                                    RunTimeSharedDictionary* dynamic_dict,
228                                                    Symbol* name);
229 
230   static bool has_platform_or_app_classes();
231 
232   // Called by PLATFORM/APP loader only
233   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
234                                                Handle class_loader,
235                                                TRAPS);
236 
237   static void preload_archived_classes(TRAPS);
238 
239   static void allocate_shared_data_arrays(int size, TRAPS);
240 
241   static bool is_builtin_loader(ClassLoaderData* loader_data);
242 
243   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
244                                                             Symbol* super_name,  bool is_superclass);
245 
246   static void initialize() NOT_CDS_RETURN;
247   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
248   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
249 
250   static bool can_be_preinited(InstanceKlass* ik);
251   static bool can_be_preinited_locked(InstanceKlass* ik);
252   static void reset_preinit_check();
253 
254   static Dictionary* boot_loader_dictionary() {
255     return ClassLoaderData::the_null_class_loader_data()->dictionary();
256   }
257 
258   static void update_shared_entry(InstanceKlass* klass, int id);
259   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
260 
261   static InstanceKlass* lookup_from_stream(Symbol* class_name,
262                                            Handle class_loader,
263                                            Handle protection_domain,
264                                            const ClassFileStream* st,
265                                            TRAPS);
266   // "verification_constraints" are a set of checks performed by
267   // VerificationType::is_reference_assignable_from when verifying a shared class during
268   // dump time.
269   //
270   // With AppCDS, it is possible to override archived classes by calling
271   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
272   // ensures that you cannot load a shared class if its super type(s) are changed. However,
273   // we need an additional check to ensure that the verification_constraints did not change

284                                      InstanceKlass* lambda_ik,
285                                      Symbol* invoked_name,
286                                      Symbol* invoked_type,
287                                      Symbol* method_type,
288                                      Method* member_method,
289                                      Symbol* instantiated_method_type, TRAPS) NOT_CDS_RETURN;
290   static void add_to_dump_time_lambda_proxy_class_dictionary(LambdaProxyClassKey& key,
291                                                              InstanceKlass* proxy_klass) NOT_CDS_RETURN;
292   static InstanceKlass* get_shared_lambda_proxy_class(InstanceKlass* caller_ik,
293                                                       Symbol* invoked_name,
294                                                       Symbol* invoked_type,
295                                                       Symbol* method_type,
296                                                       Method* member_method,
297                                                       Symbol* instantiated_method_type) NOT_CDS_RETURN_(nullptr);
298   static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(nullptr);
299   static InstanceKlass* prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik,
300                                                           InstanceKlass* caller_ik, TRAPS) NOT_CDS_RETURN_(nullptr);
301   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
302   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
303                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
304   static bool is_builtin(const InstanceKlass* k) {
305     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
306   }
307   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
308 
309   static void check_excluded_classes();
310   static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
311   static void validate_before_archiving(InstanceKlass* k);
312   static bool is_excluded_class(InstanceKlass* k);
313   static void set_excluded(InstanceKlass* k);
314   static void set_excluded_locked(InstanceKlass* k);
315   static bool warn_excluded(InstanceKlass* k, const char* reason);
316   static void dumptime_classes_do(class MetaspaceClosure* it);
317   static size_t estimate_size_for_archive();
318   static void write_to_archive(bool is_static_archive = true);
319   static void adjust_lambda_proxy_class_dictionary();
320 
321   static void adjust_method_info_dictionary();
322 
323   static void serialize_dictionary_headers(class SerializeClosure* soc,
324                                            bool is_static_archive = true);
325   static void serialize_vm_classes(class SerializeClosure* soc);
326   static void print() { return print_on(tty); }
327   static void print_on(outputStream* st) NOT_CDS_RETURN;
328   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
329   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
330   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
331   static bool is_supported_invokedynamic(BootstrapInfo* bsi) NOT_CDS_RETURN_(false);
332   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
333 
334   static MethodData* lookup_method_data(Method* m) {
335     const RunTimeMethodDataInfo* info = _dynamic_archive.lookup_method_info(m);
336     if (info != nullptr) {
337       return info->method_data();
338     }
339     return nullptr;
340   }
341 
342   static MethodCounters* lookup_method_counters(Method* m) {
343     const RunTimeMethodDataInfo* info = _dynamic_archive.lookup_method_info(m);
344     if (info != nullptr) {
345       return info->method_counters();
346     }
347     return nullptr;
348   }
349 
350 #ifdef ASSERT
351   // This object marks a critical period when writing the CDS archive. During this
352   // period, the JVM must not load any new classes, so as to avoid adding new
353   // items in the SystemDictionaryShared::_dumptime_table.
354   class NoClassLoadingMark: public StackObj {
355   public:
356     NoClassLoadingMark() {
357       assert(_class_loading_may_happen, "must not be nested");
358       _class_loading_may_happen = false;
359     }
360     ~NoClassLoadingMark() {
361       _class_loading_may_happen = true;
362     }
363   };
364 #endif
365 
366   template <typename T>
367   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
368     assert(MetaspaceObj::is_shared((const MetaspaceObj*)ptr), "must be");
369     assert(ptr > (T*)SharedBaseAddress, "must be");
370     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
371     return primitive_hash<uintx>(offset);
372   }
373 
374   static unsigned int hash_for_shared_dictionary(address ptr);
375   static const char* class_loader_name_for_shared(Klass* k);
376   static void create_loader_positive_lookup_cache(TRAPS);
377 };
378 
379 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
< prev index next >