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 
 60 [2] How classes from different categories are specified in the classlist:
 61 
 62     Starting from JDK9, each class in the classlist may be specified with
 63     these keywords: "id", "super", "interfaces", "loader" and "source".
 64 
 65 
 66     BUILTIN               Only the "id" keyword may be (optionally) specified. All other
 67                           keywords are forbidden.
 68 
 69                           The named class is looked up from the jimage and from
 70                           Xbootclasspath/a and CLASSPATH.
 71 
 72     UNREGISTERED:         The "id", "super", and "source" keywords must all be
 73                           specified.
 74 
 75                           The "interfaces" keyword must be specified if the class implements
 76                           one or more local interfaces. The "interfaces" keyword must not be
 77                           specified if the class does not implement local interfaces.
 78 
 79                           The named class is looked up from the location specified in the
 80                           "source" keyword.
 81 
 82     Example classlist:
 83 
 84     # BUILTIN
 85     java/lang/Object id: 0
 86     java/lang/Cloneable id: 1
 87     java/lang/String
 88 
 89     # UNREGISTERED
 90     Bar id: 3 super: 0 interfaces: 1 source: /foo.jar
 91 
 92 
 93 [3] Identifying the category of archived classes
 94 
 95     BUILTIN:              (C->shared_classpath_index() >= 0)
 96     UNREGISTERED:         (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
 97 
 98 [4] Lookup of archived classes at run time:
 99 
100     (a) BUILTIN loaders:
101 
102         search _builtin_dictionary
103 
104     (b) UNREGISTERED loaders:
105 
106         search _unregistered_dictionary for an entry that matches the
107         (name, clsfile_len, clsfile_crc32).
108 
109 ===============================================================================*/
110 #define UNREGISTERED_INDEX -9999
111 
112 class BootstrapInfo;
113 class ClassFileStream;
114 class ConstantPoolCache;
115 class Dictionary;
116 class DumpTimeClassInfo;
117 class DumpTimeSharedClassTable;
118 class LambdaProxyClassDictionary;
119 class RunTimeClassInfo;
120 class RunTimeSharedDictionary;
121 class DumpTimeLambdaProxyClassDictionary;
122 class LambdaProxyClassKey;
123 
124 class SharedClassLoadingMark {
125  private:
126   Thread* THREAD;
127   InstanceKlass* _klass;
128  public:
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
274   // between dump time and runtime.
275   static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
276                   Symbol* from_name, bool from_field_is_protected,
277                   bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
278   static void check_verification_constraints(InstanceKlass* klass,
279                                              TRAPS) NOT_CDS_RETURN;
280   static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
281   static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
282   static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
283   static void add_lambda_proxy_class(InstanceKlass* caller_ik,
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