1 /*
  2  * Copyright (c) 2014, 2025, 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/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 
 58 [2] How classes from different categories are specified in the classlist:
 59 
 60     Starting from JDK9, each class in the classlist may be specified with
 61     these keywords: "id", "super", "interfaces", "loader" and "source".
 62 
 63 
 64     BUILTIN               Only the "id" keyword may be (optionally) specified. All other
 65                           keywords are forbidden.
 66 
 67                           The named class is looked up from the jimage and from
 68                           Xbootclasspath/a and CLASSPATH.
 69 
 70     UNREGISTERED:         The "id", "super", and "source" keywords must all be
 71                           specified.
 72 
 73                           The "interfaces" keyword must be specified if the class implements
 74                           one or more local interfaces. The "interfaces" keyword must not be
 75                           specified if the class does not implement local interfaces.
 76 
 77                           The named class is looked up from the location specified in the
 78                           "source" keyword.
 79 
 80     Example classlist:
 81 
 82     # BUILTIN
 83     java/lang/Object id: 0
 84     java/lang/Cloneable id: 1
 85     java/lang/String
 86 
 87     # UNREGISTERED
 88     Bar id: 3 super: 0 interfaces: 1 source: /foo.jar
 89 
 90 
 91 [3] Identifying the category of archived classes
 92 
 93     BUILTIN:              (C->shared_classpath_index() >= 0)
 94     UNREGISTERED:         (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
 95 
 96 [4] Lookup of archived classes at run time:
 97 
 98     (a) BUILTIN loaders:
 99 
100         search _builtin_dictionary
101 
102     (b) UNREGISTERED loaders:
103 
104         search _unregistered_dictionary for an entry that matches the
105         (name, clsfile_len, clsfile_crc32).
106 
107 ===============================================================================*/
108 #define UNREGISTERED_INDEX -9999
109 
110 class BootstrapInfo;
111 class ClassFileStream;
112 class ConstantPoolCache;
113 class Dictionary;
114 class DumpTimeClassInfo;
115 class DumpTimeSharedClassTable;
116 class RunTimeClassInfo;
117 class RunTimeSharedDictionary;
118 
119 template <typename E> class GrowableArray;
120 
121 class SharedClassLoadingMark {
122  private:
123   Thread* THREAD;
124   InstanceKlass* _klass;
125  public:
126   SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
127   ~SharedClassLoadingMark() {
128     assert(THREAD != nullptr, "Current thread is nullptr");
129     assert(_klass != nullptr, "InstanceKlass is nullptr");
130     if (HAS_PENDING_EXCEPTION) {
131       if (_klass->in_aot_cache()) {
132         _klass->set_shared_loading_failed();
133       }
134     }
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
261   // between dump time and runtime.
262   static void add_verification_constraint(InstanceKlass* k, Symbol* name,
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);
303   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
304 
305 #ifdef ASSERT
306   // This object marks a critical period when writing the CDS archive. During this
307   // period, the JVM must not load any new classes, so as to avoid adding new
308   // items in the SystemDictionaryShared::_dumptime_table.
309   class NoClassLoadingMark: public StackObj {
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