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/filemap.hpp"
 30 #include "cds/dumpTimeClassInfo.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 class SharedClassLoadingMark {
120  private:
121   Thread* THREAD;
122   InstanceKlass* _klass;
123  public:
124   SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
125   ~SharedClassLoadingMark() {
126     assert(THREAD != nullptr, "Current thread is nullptr");
127     assert(_klass != nullptr, "InstanceKlass is nullptr");
128     if (HAS_PENDING_EXCEPTION) {
129       if (_klass->is_shared()) {
130         _klass->set_shared_loading_failed();
131       }
132     }
133   }
134 };
135 
136 class SystemDictionaryShared: public SystemDictionary {
137   friend class LambdaProxyClassDictionary;
138 
139   struct ArchiveInfo {
140     RunTimeSharedDictionary _builtin_dictionary;
141     RunTimeSharedDictionary _unregistered_dictionary;
142 
143     void print_on(const char* prefix, outputStream* st, bool is_static_archive);
144     void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive);
145   };
146 
147 private:
148 
149   static DumpTimeSharedClassTable* _dumptime_table;
150 
151   static ArchiveInfo _static_archive;
152   static ArchiveInfo _dynamic_archive;
153 
154   static ArchiveInfo* get_archive(bool is_static_archive) {
155     return is_static_archive ? &_static_archive : &_dynamic_archive;
156   }
157 
158   static InstanceKlass* load_shared_class_for_builtin_loader(
159                                                Symbol* class_name,
160                                                Handle class_loader,
161                                                TRAPS);
162   static InstanceKlass* acquire_class_for_current_thread(
163                                  InstanceKlass *ik,
164                                  Handle class_loader,
165                                  Handle protection_domain,
166                                  const ClassFileStream* cfs,
167                                  TRAPS);
168 
169 
170   static void write_dictionary(RunTimeSharedDictionary* dictionary,
171                                bool is_builtin);
172   static bool check_for_exclusion_impl(InstanceKlass* k);
173   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
174   DEBUG_ONLY(static bool _class_loading_may_happen;)
175 
176   static void copy_verification_constraints_from_preimage(InstanceKlass* klass);
177   static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
178 
179 public:
180   // Guaranteed to return non-null value for non-shared classes.
181   // k must not be a shared class.
182   static DumpTimeClassInfo* get_info(InstanceKlass* k);
183   static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
184   static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
185 
186   static bool should_hidden_class_be_archived(InstanceKlass* k);
187   static void mark_required_hidden_class(InstanceKlass* k);
188   static bool has_been_redefined(InstanceKlass* k);
189   static bool is_jfr_event_class(InstanceKlass *k);
190   static bool is_early_klass(InstanceKlass* k);   // Was k loaded while JvmtiExport::is_early_phase()==true
191   static bool has_archived_enum_objs(InstanceKlass* ik);
192   static void set_has_archived_enum_objs(InstanceKlass* ik);
193 
194   static InstanceKlass* find_builtin_class(Symbol* class_name);
195 
196   static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
197                                                    RunTimeSharedDictionary* dynamic_dict,
198                                                    Symbol* name);
199 
200   static bool has_platform_or_app_classes();
201 
202   // Called by PLATFORM/APP loader only
203   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
204                                                Handle class_loader,
205                                                TRAPS);
206 
207 
208   static void allocate_shared_data_arrays(int size, TRAPS);
209 
210   static bool is_builtin_loader(ClassLoaderData* loader_data);
211 
212   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
213                                                             Symbol* super_name,  bool is_superclass);
214 
215   static void initialize() NOT_CDS_RETURN;
216   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
217   static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
218   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
219 
220   static bool can_be_preinited(InstanceKlass* ik);
221   static bool can_be_preinited_locked(InstanceKlass* ik);
222   static void reset_preinit_check();
223 
224   static Dictionary* boot_loader_dictionary() {
225     return ClassLoaderData::the_null_class_loader_data()->dictionary();
226   }
227 
228   static void update_shared_entry(InstanceKlass* klass, int id);
229   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
230 
231   static InstanceKlass* lookup_from_stream(Symbol* class_name,
232                                            Handle class_loader,
233                                            Handle protection_domain,
234                                            const ClassFileStream* st,
235                                            TRAPS);
236   // "verification_constraints" are a set of checks performed by
237   // VerificationType::is_reference_assignable_from when verifying a shared class during
238   // dump time.
239   //
240   // With AppCDS, it is possible to override archived classes by calling
241   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
242   // ensures that you cannot load a shared class if its super type(s) are changed. However,
243   // we need an additional check to ensure that the verification_constraints did not change
244   // between dump time and runtime.
245   static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
246                   Symbol* from_name, bool from_field_is_protected,
247                   bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
248   static void check_verification_constraints(InstanceKlass* klass,
249                                              TRAPS) NOT_CDS_RETURN;
250   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
251   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
252   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
253   static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
254   static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
255                                      Handle loader1, Handle loader2) NOT_CDS_RETURN;
256   static bool is_builtin(const InstanceKlass* k) {
257     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
258   }
259   static bool add_unregistered_class(Thread* current, InstanceKlass* k);
260   static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
261 
262   static void finish_exclusion_checks();
263 
264   static bool should_be_excluded(Klass* k);
265   static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
266   static void validate_before_archiving(InstanceKlass* k);
267   static bool is_excluded_class(InstanceKlass* k);
268   static void set_excluded(InstanceKlass* k);
269   static void set_excluded_locked(InstanceKlass* k);
270   static bool warn_excluded(InstanceKlass* k, const char* reason);
271   static void dumptime_classes_do(class MetaspaceClosure* it);
272   static void write_to_archive(bool is_static_archive = true);
273   static void serialize_dictionary_headers(class SerializeClosure* soc,
274                                            bool is_static_archive = true);
275   static void serialize_vm_classes(class SerializeClosure* soc);
276   static const char* loader_type_for_shared_class(Klass* k);
277   static void print() { return print_on(tty); }
278   static void print_on(outputStream* st) NOT_CDS_RETURN;
279   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
280   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
281   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
282   DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
283 
284 #ifdef ASSERT
285   // This object marks a critical period when writing the CDS archive. During this
286   // period, the JVM must not load any new classes, so as to avoid adding new
287   // items in the SystemDictionaryShared::_dumptime_table.
288   class NoClassLoadingMark: public StackObj {
289   public:
290     NoClassLoadingMark() {
291       assert(_class_loading_may_happen, "must not be nested");
292       _class_loading_may_happen = false;
293     }
294     ~NoClassLoadingMark() {
295       _class_loading_may_happen = true;
296     }
297   };
298 #endif
299 
300   template <typename T>
301   static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
302     assert(MetaspaceObj::is_shared((const MetaspaceObj*)ptr), "must be");
303     assert(ptr > (T*)SharedBaseAddress, "must be");
304     uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
305     return primitive_hash<uintx>(offset);
306   }
307 
308   static unsigned int hash_for_shared_dictionary(address ptr);
309   static void create_loader_positive_lookup_cache(TRAPS);
310 };
311 
312 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP