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 
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 check_for_exclusion_impl(InstanceKlass* k);
179   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
180   static bool has_been_redefined(InstanceKlass* k);
181   DEBUG_ONLY(static bool _class_loading_may_happen;)
182 
183   static void copy_verification_constraints_from_preimage(InstanceKlass* klass);
184   static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
185 
186 public:
187   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
188   static bool has_archived_enum_objs(InstanceKlass* ik);
189   static void set_has_archived_enum_objs(InstanceKlass* ik);
190 
191   static InstanceKlass* find_builtin_class(Symbol* class_name);
192 
193   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
194                                                    RunTimeSharedDictionary* dynamic_dict,
195                                                    Symbol* name);
196 
197   static bool has_platform_or_app_classes();
198 
199   // Called by PLATFORM/APP loader only
200   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
201                                                Handle class_loader,
202                                                TRAPS);
203 
204 
205   static void allocate_shared_data_arrays(int size, TRAPS);
206 
207   static bool is_builtin_loader(ClassLoaderData* loader_data);
208 
209   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
210                                                             Symbol* super_name,  bool is_superclass);
211 
212   static void initialize() NOT_CDS_RETURN;
213   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
214   static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
215   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
216 
217   static Dictionary* boot_loader_dictionary() {
218     return ClassLoaderData::the_null_class_loader_data()->dictionary();
219   }
220 
221   static void update_shared_entry(InstanceKlass* klass, int id);
222   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
223 
224   static InstanceKlass* lookup_from_stream(Symbol* class_name,
225                                            Handle class_loader,
226                                            Handle protection_domain,
227                                            const ClassFileStream* st,
228                                            TRAPS);
229   // "verification_constraints" are a set of checks performed by
230   // VerificationType::is_reference_assignable_from when verifying a shared class during
231   // dump time.
232   //
233   // With AppCDS, it is possible to override archived classes by calling
234   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
235   // ensures that you cannot load a shared class if its super type(s) are changed. However,
236   // we need an additional check to ensure that the verification_constraints did not change
237   // between dump time and runtime.
238   static void add_verification_constraint(InstanceKlass* k, Symbol* name,
239                   Symbol* from_name, bool from_field_is_protected,
240                   bool from_is_array, bool from_is_object,
241                   bool* skip_assignability_check);
242   static void check_verification_constraints(InstanceKlass* klass,
243                                              TRAPS) NOT_CDS_RETURN;
244   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
245   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
246   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
247   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
248   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
249                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
250   static bool is_builtin(const InstanceKlass* k) {
251     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
252   }
253   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
254   static InstanceKlass* get_unregistered_class(Symbol* name);
255   static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
256 
257   static void finish_exclusion_checks();
258   static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
259 
260   static bool should_be_excluded(Klass* k);
261   static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
262   static void validate_before_archiving(InstanceKlass* k);
263   static bool is_excluded_class(InstanceKlass* k);
264   static void set_excluded(InstanceKlass* k);
265   static void set_excluded_locked(InstanceKlass* k);
266   static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
267   static bool warn_excluded(InstanceKlass* k, const char* reason);
268   static void dumptime_classes_do(class MetaspaceClosure* it);
269   static void write_to_archive(bool is_static_archive = true);
270   static void serialize_dictionary_headers(class SerializeClosure* soc,
271                                            bool is_static_archive = true);
272   static void serialize_vm_classes(class SerializeClosure* soc);
273   static const char* loader_type_for_shared_class(Klass* k);
274   static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes);
275   static void print() { return print_on(tty); }
276   static void print_on(outputStream* st) NOT_CDS_RETURN;
277   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
278   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
279   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
280   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
281 
282 #ifdef ASSERT
283   // This object marks a critical period when writing the CDS archive. During this
284   // period, the JVM must not load any new classes, so as to avoid adding new
285   // items in the SystemDictionaryShared::_dumptime_table.
286   class NoClassLoadingMark: public StackObj {
287   public:
288     NoClassLoadingMark() {
289       assert(_class_loading_may_happen, "must not be nested");
290       _class_loading_may_happen = false;
291     }
292     ~NoClassLoadingMark() {
293       _class_loading_may_happen = true;
294     }
295   };
296 #endif
297 
298   template <typename T>
299   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
300     assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be");
301     assert(ptr > (T*)SharedBaseAddress, "must be");
302     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
303     return primitive_hash<uintx>(offset);
304   }
305 
306   static unsigned int hash_for_shared_dictionary(address ptr);
307 };
308 
309 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP