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 
 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 
 57 [2] How classes from different categories are specified in the classlist:
 58 
 59     Starting from JDK9, each class in the classlist may be specified with
 60     these keywords: "id", "super", "interfaces", "loader" and "source".
 61 
 62 
 63     BUILTIN               Only the "id" keyword may be (optionally) specified. All other
 64                           keywords are forbidden.
 65 
 66                           The named class is looked up from the jimage and from
 67                           Xbootclasspath/a and CLASSPATH.
 68 
 69     UNREGISTERED:         The "id", "super", and "source" keywords must all be
 70                           specified.
 71 
 72                           The "interfaces" keyword must be specified if the class implements
 73                           one or more local interfaces. The "interfaces" keyword must not be
 74                           specified if the class does not implement local interfaces.
 75 
 76                           The named class is looked up from the location specified in the
 77                           "source" keyword.
 78 
 79     Example classlist:
 80 
 81     # BUILTIN
 82     java/lang/Object id: 0
 83     java/lang/Cloneable id: 1
 84     java/lang/String
 85 
 86     # UNREGISTERED
 87     Bar id: 3 super: 0 interfaces: 1 source: /foo.jar
 88 
 89 
 90 [3] Identifying the category of archived classes
 91 
 92     BUILTIN:              (C->shared_classpath_index() >= 0)
 93     UNREGISTERED:         (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
 94 
 95 [4] Lookup of archived classes at run time:
 96 
 97     (a) BUILTIN loaders:
 98 
 99         search _builtin_dictionary
100 
101     (b) UNREGISTERED loaders:
102 
103         search _unregistered_dictionary for an entry that matches the
104         (name, clsfile_len, clsfile_crc32).
105 
106 ===============================================================================*/
107 #define UNREGISTERED_INDEX -9999
108 
109 class BootstrapInfo;
110 class ClassFileStream;
111 class ConstantPoolCache;
112 class Dictionary;
113 class DumpTimeClassInfo;
114 class DumpTimeSharedClassTable;
115 class RunTimeClassInfo;
116 class RunTimeSharedDictionary;
117 
118 template <typename E> class GrowableArray;
119 
120 class SharedClassLoadingMark {
121  private:
122   Thread* THREAD;
123   InstanceKlass* _klass;
124  public:
125   SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
126   ~SharedClassLoadingMark() {
127     assert(THREAD != nullptr, "Current thread is nullptr");
128     assert(_klass != nullptr, "InstanceKlass is nullptr");
129     if (HAS_PENDING_EXCEPTION) {
130       if (_klass->in_aot_cache()) {
131         _klass->set_shared_loading_failed();
132       }
133     }
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 bool check_dependencies_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
184   static bool check_verification_constraint_exclusion(InstanceKlass* k, Symbol* constraint_class_name);
185   static bool is_dependency_excluded(InstanceKlass* k, InstanceKlass* dependency, const char* type);
186   static bool is_excluded_verification_constraint(InstanceKlass* k, Symbol* constraint_class_name);
187   static Klass* find_verification_constraint_bottom_class(InstanceKlass* k, Symbol* constraint_class_name);
188 
189   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
190   static bool has_been_redefined(InstanceKlass* k);
191   DEBUG_ONLY(static bool _class_loading_may_happen;)
192 
193   static void copy_verification_info_from_preimage(InstanceKlass* klass);
194   static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
195 
196   template<typename Function>
197   static void iterate_verification_constraint_names(InstanceKlass* k, DumpTimeClassInfo* info, Function func);
198 
199 public:
200   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
201   static bool has_archived_enum_objs(InstanceKlass* ik);
202   static void set_has_archived_enum_objs(InstanceKlass* ik);
203 
204   static InstanceKlass* find_builtin_class(Symbol* class_name);
205 
206   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
207                                                    RunTimeSharedDictionary* dynamic_dict,
208                                                    Symbol* name);
209 
210   static bool has_platform_or_app_classes();
211 
212   // Called by PLATFORM/APP loader only
213   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
214                                                Handle class_loader,
215                                                TRAPS);
216 
217 
218   static void allocate_shared_data_arrays(int size, TRAPS);
219 
220   static bool is_builtin_loader(ClassLoaderData* loader_data);
221 
222   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
223                                                             Symbol* super_name,  bool is_superclass);
224 
225   static void initialize() NOT_CDS_RETURN;
226   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
227   static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
228   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
229 
230   static Dictionary* boot_loader_dictionary() {
231     return ClassLoaderData::the_null_class_loader_data()->dictionary();
232   }
233 
234   static void update_shared_entry(InstanceKlass* klass, int id);
235   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
236 
237   static InstanceKlass* lookup_from_stream(Symbol* class_name,
238                                            Handle class_loader,
239                                            Handle protection_domain,
240                                            const ClassFileStream* st,
241                                            TRAPS);
242   // "verification_constraints" are a set of checks performed by
243   // VerificationType::is_reference_assignable_from when verifying a shared class during
244   // dump time.
245   //
246   // With AppCDS, it is possible to override archived classes by calling
247   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
248   // ensures that you cannot load a shared class if its super type(s) are changed. However,
249   // we need an additional check to ensure that the verification_constraints did not change
250   // between dump time and runtime.
251   static void add_verification_constraint(InstanceKlass* k, Symbol* name,
252                   Symbol* from_name, bool from_field_is_protected,
253                   bool from_is_array, bool from_is_object,
254                   bool* skip_assignability_check);
255   static void add_old_verification_constraint(Thread* current, InstanceKlass* k, Symbol* name);
256   static void check_verification_constraints(InstanceKlass* klass,
257                                              TRAPS) NOT_CDS_RETURN;
258   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
259   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
260   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
261   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
262   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
263                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
264   static bool is_builtin(const InstanceKlass* k) {
265     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
266   }
267   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
268   static InstanceKlass* get_unregistered_class(Symbol* name);
269   static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
270 
271   static void finish_exclusion_checks();
272   static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
273 
274   static bool should_be_excluded(Klass* k);
275   static void validate_before_archiving(InstanceKlass* k);
276   static bool is_excluded_class(InstanceKlass* k);
277   static void set_excluded(InstanceKlass* k);
278   static void set_excluded_locked(InstanceKlass* k);
279   static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
280   static bool warn_excluded(InstanceKlass* k, const char* reason);
281   static void dumptime_classes_do(class MetaspaceClosure* it);
282   static void write_to_archive(bool is_static_archive = true);
283   static void serialize_dictionary_headers(class SerializeClosure* soc,
284                                            bool is_static_archive = true);
285   static void serialize_vm_classes(class SerializeClosure* soc);
286   static const char* loader_type_for_shared_class(Klass* k);
287   static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes);
288   static void print() { return print_on(tty); }
289   static void print_on(outputStream* st) NOT_CDS_RETURN;
290   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
291   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
292   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
293   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
294 
295 #ifdef ASSERT
296   // This object marks a critical period when writing the CDS archive. During this
297   // period, the JVM must not load any new classes, so as to avoid adding new
298   // items in the SystemDictionaryShared::_dumptime_table.
299   class NoClassLoadingMark: public StackObj {
300   public:
301     NoClassLoadingMark() {
302       assert(_class_loading_may_happen, "must not be nested");
303       _class_loading_may_happen = false;
304     }
305     ~NoClassLoadingMark() {
306       _class_loading_may_happen = true;
307     }
308   };
309 #endif
310 
311   template <typename T>
312   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
313     assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be");
314     assert(ptr > (T*)SharedBaseAddress, "must be");
315     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
316     return primitive_hash<uintx>(offset);
317   }
318 
319   static unsigned int hash_for_shared_dictionary(address ptr);
320 };
321 
322 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP