1 /*
  2  * Copyright (c) 2023, 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 #include "precompiled.hpp"
 26 #include "cds/archiveHeapLoader.hpp"
 27 #include "cds/cdsConfig.hpp"
 28 #include "cds/cds_globals.hpp"
 29 #include "cds/classListWriter.hpp"
 30 #include "cds/heapShared.hpp"
 31 #include "cds/metaspaceShared.hpp"
 32 #include "classfile/classLoaderDataShared.hpp"
 33 #include "classfile/moduleEntry.hpp"
 34 #include "classfile/systemDictionaryShared.hpp"
 35 #include "include/jvm_io.h"
 36 #include "logging/log.hpp"
 37 #include "prims/jvmtiExport.hpp"
 38 #include "memory/universe.hpp"
 39 #include "runtime/arguments.hpp"
 40 #include "runtime/globals_extension.hpp"
 41 #include "runtime/java.hpp"
 42 #include "utilities/defaultStream.hpp"
 43 
 44 bool CDSConfig::_is_dumping_static_archive = false;
 45 bool CDSConfig::_is_dumping_dynamic_archive = false;
 46 bool CDSConfig::_is_using_optimized_module_handling = true;
 47 bool CDSConfig::_is_dumping_full_module_graph = true;
 48 bool CDSConfig::_is_using_full_module_graph = true;
 49 bool CDSConfig::_has_preloaded_classes = false;
 50 bool CDSConfig::_is_loading_invokedynamic = false;
 51 bool CDSConfig::_is_loading_packages = false;
 52 
 53 char* CDSConfig::_default_archive_path = nullptr;
 54 char* CDSConfig::_static_archive_path = nullptr;
 55 char* CDSConfig::_dynamic_archive_path = nullptr;
 56 
 57 int CDSConfig::get_status() {
 58   assert(Universe::is_fully_initialized(), "status is finalized only after Universe is initialized");
 59   return (is_dumping_archive()              ? IS_DUMPING_ARCHIVE : 0) |
 60          (is_dumping_static_archive()       ? IS_DUMPING_STATIC_ARCHIVE : 0) |
 61          (is_logging_lambda_form_invokers() ? IS_LOGGING_LAMBDA_FORM_INVOKERS : 0) |
 62          (is_using_archive()                ? IS_USING_ARCHIVE : 0) |
 63          (is_dumping_heap()                 ? IS_DUMPING_HEAP : 0) |
 64          (is_tracing_dynamic_proxy()        ? IS_LOGGING_DYNAMIC_PROXIES : 0) |
 65          (is_dumping_packages()             ? IS_DUMPING_PACKAGES : 0);
 66 }
 67 
 68 
 69 void CDSConfig::initialize() {
 70   if (is_dumping_static_archive() && !is_dumping_final_static_archive()) {
 71     if (RequireSharedSpaces) {
 72       warning("Cannot dump shared archive while using shared archive");
 73     }
 74     UseSharedSpaces = false;
 75   }
 76 
 77   // Initialize shared archive paths which could include both base and dynamic archive paths
 78   // This must be after set_ergonomics_flags() called so flag UseCompressedOops is set properly.
 79   //
 80   // UseSharedSpaces may be disabled if -XX:SharedArchiveFile is invalid.
 81   if (is_dumping_static_archive() || UseSharedSpaces) {
 82     init_shared_archive_paths();
 83   }
 84 
 85   if (!is_dumping_heap()) {
 86     _is_dumping_full_module_graph = false;
 87   }
 88 }
 89 
 90 char* CDSConfig::default_archive_path() {
 91   if (_default_archive_path == nullptr) {
 92     char jvm_path[JVM_MAXPATHLEN];
 93     os::jvm_path(jvm_path, sizeof(jvm_path));
 94     char *end = strrchr(jvm_path, *os::file_separator());
 95     if (end != nullptr) *end = '\0';
 96     size_t jvm_path_len = strlen(jvm_path);
 97     size_t file_sep_len = strlen(os::file_separator());
 98     const size_t len = jvm_path_len + file_sep_len + 20;
 99     _default_archive_path = NEW_C_HEAP_ARRAY(char, len, mtArguments);
100     jio_snprintf(_default_archive_path, len,
101                 LP64_ONLY(!UseCompressedOops ? "%s%sclasses_nocoops.jsa":) "%s%sclasses.jsa",
102                 jvm_path, os::file_separator());
103   }
104   return _default_archive_path;
105 }
106 
107 int CDSConfig::num_archives(const char* archive_path) {
108   if (archive_path == nullptr) {
109     return 0;
110   }
111   int npaths = 1;
112   char* p = (char*)archive_path;
113   while (*p != '\0') {
114     if (*p == os::path_separator()[0]) {
115       npaths++;
116     }
117     p++;
118   }
119   return npaths;
120 }
121 
122 void CDSConfig::extract_shared_archive_paths(const char* archive_path,
123                                              char** base_archive_path,
124                                              char** top_archive_path) {
125   char* begin_ptr = (char*)archive_path;
126   char* end_ptr = strchr((char*)archive_path, os::path_separator()[0]);
127   if (end_ptr == nullptr || end_ptr == begin_ptr) {
128     vm_exit_during_initialization("Base archive was not specified", archive_path);
129   }
130   size_t len = end_ptr - begin_ptr;
131   char* cur_path = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
132   strncpy(cur_path, begin_ptr, len);
133   cur_path[len] = '\0';
134   *base_archive_path = cur_path;
135 
136   begin_ptr = ++end_ptr;
137   if (*begin_ptr == '\0') {
138     vm_exit_during_initialization("Top archive was not specified", archive_path);
139   }
140   end_ptr = strchr(begin_ptr, '\0');
141   assert(end_ptr != nullptr, "sanity");
142   len = end_ptr - begin_ptr;
143   cur_path = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
144   strncpy(cur_path, begin_ptr, len + 1);
145   *top_archive_path = cur_path;
146 }
147 
148 static void set_new_workflow_default_CachedCodeFile() {
149   size_t len = strlen(CacheDataStore) + 6;
150   char* file = AllocateHeap(len, mtArguments);
151   jio_snprintf(file, len, "%s.code", CacheDataStore);
152   FLAG_SET_ERGO(CachedCodeFile, file);
153 }
154 
155 void CDSConfig::init_shared_archive_paths() {
156   if (ArchiveClassesAtExit != nullptr) {
157     assert(!RecordDynamicDumpInfo, "already checked");
158     if (is_dumping_static_archive()) {
159       vm_exit_during_initialization("-XX:ArchiveClassesAtExit cannot be used with -Xshare:dump");
160     }
161     check_unsupported_dumping_module_options();
162 
163     if (os::same_files(default_archive_path(), ArchiveClassesAtExit)) {
164       vm_exit_during_initialization(
165         "Cannot specify the default CDS archive for -XX:ArchiveClassesAtExit", default_archive_path());
166     }
167   }
168 
169   if (SharedArchiveFile == nullptr) {
170     _static_archive_path = default_archive_path();
171   } else {
172     int archives = num_archives(SharedArchiveFile);
173     assert(archives > 0, "must be");
174 
175     if (is_dumping_archive() && archives > 1) {
176       vm_exit_during_initialization(
177         "Cannot have more than 1 archive file specified in -XX:SharedArchiveFile during CDS dumping");
178     }
179 
180     if (CDSPreimage != nullptr && archives > 1) {
181       vm_exit_during_initialization("CDSPreimage must point to a single file", CDSPreimage);
182     }
183 
184     if (is_dumping_static_archive()) {
185       assert(archives == 1, "must be");
186       // Static dump is simple: only one archive is allowed in SharedArchiveFile. This file
187       // will be overwritten no matter regardless of its contents
188       _static_archive_path = os::strdup_check_oom(SharedArchiveFile, mtArguments);
189     } else {
190       // SharedArchiveFile may specify one or two files. In case (c), the path for base.jsa
191       // is read from top.jsa
192       //    (a) 1 file:  -XX:SharedArchiveFile=base.jsa
193       //    (b) 2 files: -XX:SharedArchiveFile=base.jsa:top.jsa
194       //    (c) 2 files: -XX:SharedArchiveFile=top.jsa
195       //
196       // However, if either RecordDynamicDumpInfo or ArchiveClassesAtExit is used, we do not
197       // allow cases (b) and (c). Case (b) is already checked above.
198 
199       if (archives > 2) {
200         vm_exit_during_initialization(
201           "Cannot have more than 2 archive files specified in the -XX:SharedArchiveFile option");
202       }
203       if (archives == 1) {
204         char* base_archive_path = nullptr;
205         bool success =
206           FileMapInfo::get_base_archive_name_from_header(SharedArchiveFile, &base_archive_path);
207         if (!success) {
208           if (CDSPreimage != nullptr) {
209             vm_exit_during_initialization("Unable to map shared spaces from CDSPreimage", CDSPreimage);
210           }
211 
212           // If +AutoCreateSharedArchive and the specified shared archive does not exist,
213           // regenerate the dynamic archive base on default archive.
214           if (AutoCreateSharedArchive && !os::file_exists(SharedArchiveFile)) {
215             enable_dumping_dynamic_archive();
216             ArchiveClassesAtExit = const_cast<char *>(SharedArchiveFile);
217             _static_archive_path = default_archive_path();
218             SharedArchiveFile = nullptr;
219           } else {
220             if (AutoCreateSharedArchive) {
221               warning("-XX:+AutoCreateSharedArchive is unsupported when base CDS archive is not loaded. Run with -Xlog:cds for more info.");
222               AutoCreateSharedArchive = false;
223             }
224             Arguments::no_shared_spaces("invalid archive");
225           }
226         } else if (base_archive_path == nullptr) {
227           // User has specified a single archive, which is a static archive.
228           _static_archive_path = const_cast<char *>(SharedArchiveFile);
229         } else {
230           // User has specified a single archive, which is a dynamic archive.
231           _dynamic_archive_path = const_cast<char *>(SharedArchiveFile);
232           _static_archive_path = base_archive_path; // has been c-heap allocated.
233         }
234       } else {
235         extract_shared_archive_paths((const char*)SharedArchiveFile,
236                                       &_static_archive_path, &_dynamic_archive_path);
237         if (_static_archive_path == nullptr) {
238           assert(_dynamic_archive_path == nullptr, "must be");
239           Arguments::no_shared_spaces("invalid archive");
240         }
241       }
242 
243       if (_dynamic_archive_path != nullptr) {
244         // Check for case (c)
245         if (RecordDynamicDumpInfo) {
246           vm_exit_during_initialization("-XX:+RecordDynamicDumpInfo is unsupported when a dynamic CDS archive is specified in -XX:SharedArchiveFile",
247                                         SharedArchiveFile);
248         }
249         if (ArchiveClassesAtExit != nullptr) {
250           vm_exit_during_initialization("-XX:ArchiveClassesAtExit is unsupported when a dynamic CDS archive is specified in -XX:SharedArchiveFile",
251                                         SharedArchiveFile);
252         }
253       }
254 
255       if (ArchiveClassesAtExit != nullptr && os::same_files(SharedArchiveFile, ArchiveClassesAtExit)) {
256           vm_exit_during_initialization(
257             "Cannot have the same archive file specified for -XX:SharedArchiveFile and -XX:ArchiveClassesAtExit",
258             SharedArchiveFile);
259       }
260     }
261   }
262 }
263 
264 void CDSConfig::check_internal_module_property(const char* key, const char* value) {
265   if (Arguments::is_internal_module_property(key)) {
266     stop_using_optimized_module_handling();
267     log_info(cds)("optimized module handling: disabled due to incompatible property: %s=%s", key, value);
268   }
269 }
270 
271 void CDSConfig::check_incompatible_property(const char* key, const char* value) {
272   static const char* incompatible_properties[] = {
273     "java.system.class.loader",
274     "jdk.module.showModuleResolution",
275     "jdk.module.validation"
276   };
277 
278   for (const char* property : incompatible_properties) {
279     if (strcmp(key, property) == 0) {
280       stop_dumping_full_module_graph();
281       stop_using_full_module_graph();
282       log_info(cds)("full module graph: disabled due to incompatible property: %s=%s", key, value);
283       break;
284     }
285   }
286 
287 }
288 
289 // Returns any JVM command-line option, such as "--patch-module", that's not supported by CDS.
290 static const char* find_any_unsupported_module_option() {
291   // Note that arguments.cpp has translated the command-line options into properties. If we find an
292   // unsupported property, translate it back to its command-line option for better error reporting.
293 
294   // The following properties are checked by Arguments::is_internal_module_property() and cannot be
295   // directly specified in the command-line.
296   static const char* unsupported_module_properties[] = {
297     "jdk.module.limitmods",
298     "jdk.module.upgrade.path",
299     "jdk.module.patch.0"
300   };
301   static const char* unsupported_module_options[] = {
302     "--limit-modules",
303     "--upgrade-module-path",
304     "--patch-module"
305   };
306 
307   assert(ARRAY_SIZE(unsupported_module_properties) == ARRAY_SIZE(unsupported_module_options), "must be");
308   SystemProperty* sp = Arguments::system_properties();
309   while (sp != nullptr) {
310     for (uint i = 0; i < ARRAY_SIZE(unsupported_module_properties); i++) {
311       if (strcmp(sp->key(), unsupported_module_properties[i]) == 0) {
312         return unsupported_module_options[i];
313       }
314     }
315     sp = sp->next();
316   }
317 
318   return nullptr; // not found
319 }
320 
321 void CDSConfig::check_unsupported_dumping_module_options() {
322   assert(is_dumping_archive(), "this function is only used with CDS dump time");
323   const char* option = find_any_unsupported_module_option();
324   if (option != nullptr) {
325     vm_exit_during_initialization("Cannot use the following option when dumping the shared archive", option);
326   }
327   // Check for an exploded module build in use with -Xshare:dump.
328   if (!Arguments::has_jimage()) {
329     vm_exit_during_initialization("Dumping the shared archive is not supported with an exploded module build");
330   }
331 }
332 
333 bool CDSConfig::has_unsupported_runtime_module_options() {
334   assert(UseSharedSpaces, "this function is only used with -Xshare:{on,auto}");
335   if (ArchiveClassesAtExit != nullptr) {
336     // dynamic dumping, just return false for now.
337     // check_unsupported_dumping_properties() will be called later to check the same set of
338     // properties, and will exit the VM with the correct error message if the unsupported properties
339     // are used.
340     return false;
341   }
342   const char* option = find_any_unsupported_module_option();
343   if (option != nullptr) {
344     if (RequireSharedSpaces) {
345       warning("CDS is disabled when the %s option is specified.", option);
346     } else {
347       log_info(cds)("CDS is disabled when the %s option is specified.", option);
348     }
349     return true;
350   }
351   return false;
352 }
353 
354 bool CDSConfig::check_vm_args_consistency(bool patch_mod_javabase, bool mode_flag_cmd_line) {
355   if (CacheDataStore != nullptr) {
356     if (FLAG_IS_DEFAULT(PreloadSharedClasses)) {
357       // New workflow - enable PreloadSharedClasses by default.
358       // TODO: make new workflow work, even when PreloadSharedClasses is false.
359       //
360       // NOTE: in old workflow, we cannot enable PreloadSharedClasses by default. That
361       // should be an opt-in option, per JEP nnn.
362       FLAG_SET_ERGO(PreloadSharedClasses, true);
363     }
364 
365     if (SharedArchiveFile != nullptr) {
366       vm_exit_during_initialization("CacheDataStore and SharedArchiveFile cannot be both specified");
367     }
368     if (!PreloadSharedClasses) {
369       // TODO: in the forked JVM, we should ensure all classes are loaded from the hotspot.cds.preimage.
370       // PreloadSharedClasses only loads the classes for built-in loaders. We need to load the classes
371       // for custom loaders as well.
372       vm_exit_during_initialization("CacheDataStore requires PreloadSharedClasses");
373     }
374 
375     if (CDSPreimage == nullptr) {
376       if (os::file_exists(CacheDataStore) /* && TODO: CDS file is valid*/) {
377         // The CacheDataStore is already up to date. Use it. Also turn on cached code by default.
378         SharedArchiveFile = CacheDataStore;
379         FLAG_SET_ERGO_IF_DEFAULT(ReplayTraining, true);
380         FLAG_SET_ERGO_IF_DEFAULT(LoadCachedCode, true);
381         if (LoadCachedCode && FLAG_IS_DEFAULT(CachedCodeFile)) {
382           set_new_workflow_default_CachedCodeFile();
383         }
384       } else {
385         // The preimage dumping phase -- run the app and write the preimage file
386         size_t len = strlen(CacheDataStore) + 10;
387         char* preimage = AllocateHeap(len, mtArguments);
388         jio_snprintf(preimage, len, "%s.preimage", CacheDataStore);
389 
390         UseSharedSpaces = false;
391         enable_dumping_static_archive();
392         SharedArchiveFile = preimage;
393         log_info(cds)("CacheDataStore needs to be updated. Writing %s file", SharedArchiveFile);
394 
395         // At VM exit, the module graph may be contaminated with program states. We should rebuild the
396         // module graph when dumping the CDS final image.
397         log_info(cds)("full module graph: disabled when writing CDS preimage");
398         HeapShared::disable_writing();
399         stop_dumping_full_module_graph();
400         FLAG_SET_ERGO(ArchiveInvokeDynamic, false);
401         FLAG_SET_ERGO(ArchivePackages, false);
402 
403         FLAG_SET_ERGO_IF_DEFAULT(RecordTraining, true);
404       }
405     } else {
406       // The final image dumping phase -- load the preimage and write the final image file
407       SharedArchiveFile = CDSPreimage;
408       UseSharedSpaces = true;
409       log_info(cds)("Generate CacheDataStore %s from CDSPreimage %s", CacheDataStore, CDSPreimage);
410       // Force -Xbatch for AOT compilation.
411       if (FLAG_SET_CMDLINE(BackgroundCompilation, false) != JVMFlag::SUCCESS) {
412         return false;
413       }
414       RecordTraining = false; // This will be updated inside MetaspaceShared::preload_and_dump()
415 
416       FLAG_SET_ERGO_IF_DEFAULT(ReplayTraining, true);
417       // Settings for AOT
418       FLAG_SET_ERGO_IF_DEFAULT(StoreCachedCode, true);
419       if (StoreCachedCode && FLAG_IS_DEFAULT(CachedCodeFile)) {
420         set_new_workflow_default_CachedCodeFile();
421         // Cannot dump cached code until metadata and heap are dumped.
422         disable_dumping_cached_code();
423       }
424     }
425   } else {
426     // Old workflow
427     if (CDSPreimage != nullptr) {
428       vm_exit_during_initialization("CDSPreimage must be specified only when CacheDataStore is specified");
429     }
430   }
431 
432   if (FLAG_IS_DEFAULT(UsePermanentHeapObjects)) {
433     if (StoreCachedCode || PreloadSharedClasses) {
434       FLAG_SET_ERGO(UsePermanentHeapObjects, true);
435     }
436   }
437 
438   if (LoadCachedCode) {
439     // This must be true. Cached code is hard-wired to use permanent objects.
440     UsePermanentHeapObjects = true;
441   }
442 
443   if (PreloadSharedClasses) {
444     // If PreloadSharedClasses is specified, enable all these optimizations by default.
445     FLAG_SET_ERGO_IF_DEFAULT(ArchiveDynamicProxies, true);
446     FLAG_SET_ERGO_IF_DEFAULT(ArchiveFieldReferences, true);
447     FLAG_SET_ERGO_IF_DEFAULT(ArchiveInvokeDynamic, true);
448     FLAG_SET_ERGO_IF_DEFAULT(ArchiveLoaderLookupCache, true);
449     FLAG_SET_ERGO_IF_DEFAULT(ArchiveMethodReferences, true);
450     FLAG_SET_ERGO_IF_DEFAULT(ArchivePackages, true);
451     FLAG_SET_ERGO_IF_DEFAULT(ArchiveReflectionData, true);
452   } else {
453     // All of these *might* depend on PreloadSharedClasses. Better be safe than sorry.
454     // TODO: more fine-grained handling.
455     FLAG_SET_ERGO(ArchiveDynamicProxies, false);
456     FLAG_SET_ERGO(ArchiveFieldReferences, false);
457     FLAG_SET_ERGO(ArchiveInvokeDynamic, false);
458     FLAG_SET_ERGO(ArchiveLoaderLookupCache, false);
459     FLAG_SET_ERGO(ArchiveMethodReferences, false);
460     FLAG_SET_ERGO(ArchivePackages, false);
461     FLAG_SET_ERGO(ArchiveReflectionData, false);
462   }
463 
464   if (is_dumping_static_archive()) {
465     if (is_dumping_preimage_static_archive() || is_dumping_final_static_archive()) {
466       // Don't tweak execution mode
467     } else if (!mode_flag_cmd_line) {
468       // By default, -Xshare:dump runs in interpreter-only mode, which is required for deterministic archive.
469       //
470       // If your classlist is large and you don't care about deterministic dumping, you can use
471       // -Xshare:dump -Xmixed to improve dumping speed.
472       Arguments::set_mode_flags(Arguments::_int);
473     } else if (Arguments::mode() == Arguments::_comp) {
474       // -Xcomp may use excessive CPU for the test tiers. Also, -Xshare:dump runs a small and fixed set of
475       // Java code, so there's not much benefit in running -Xcomp.
476       log_info(cds)("reduced -Xcomp to -Xmixed for static dumping");
477       Arguments::set_mode_flags(Arguments::_mixed);
478     }
479 
480     // String deduplication may cause CDS to iterate the strings in different order from one
481     // run to another which resulting in non-determinstic CDS archives.
482     // Disable UseStringDeduplication while dumping CDS archive.
483     UseStringDeduplication = false;
484 
485     Arguments::PropertyList_add(new SystemProperty("java.lang.invoke.MethodHandle.NO_SOFT_CACHE", "true", false));
486   } else {
487     // These flags flag are useful only when dumping static archive (which supports archived heap)
488     ArchiveInvokeDynamic = false;
489     ArchivePackages = false;
490   }
491 
492   // RecordDynamicDumpInfo is not compatible with ArchiveClassesAtExit
493   if (ArchiveClassesAtExit != nullptr && RecordDynamicDumpInfo) {
494     jio_fprintf(defaultStream::output_stream(),
495                 "-XX:+RecordDynamicDumpInfo cannot be used with -XX:ArchiveClassesAtExit.\n");
496     return false;
497   }
498 
499   if (ArchiveClassesAtExit == nullptr && !RecordDynamicDumpInfo) {
500     disable_dumping_dynamic_archive();
501   } else {
502     enable_dumping_dynamic_archive();
503   }
504 
505   if (AutoCreateSharedArchive) {
506     if (SharedArchiveFile == nullptr) {
507       log_warning(cds)("-XX:+AutoCreateSharedArchive requires -XX:SharedArchiveFile");
508       return false;
509     }
510     if (ArchiveClassesAtExit != nullptr) {
511       log_warning(cds)("-XX:+AutoCreateSharedArchive does not work with ArchiveClassesAtExit");
512       return false;
513     }
514   }
515 
516   if (UseSharedSpaces && patch_mod_javabase) {
517     Arguments::no_shared_spaces("CDS is disabled when " JAVA_BASE_NAME " module is patched.");
518   }
519   if (UseSharedSpaces && has_unsupported_runtime_module_options()) {
520     UseSharedSpaces = false;
521   }
522 
523   if (is_dumping_archive()) {
524     // Always verify non-system classes during CDS dump
525     if (!BytecodeVerificationRemote) {
526       BytecodeVerificationRemote = true;
527       log_info(cds)("All non-system classes will be verified (-Xverify:remote) during CDS dump time.");
528     }
529   }
530 
531   if (!is_dumping_static_archive() || !PreloadSharedClasses) {
532     // FIXME -- is_dumping_heap() is not yet callable from here, as UseG1GC is not yet set by ergo!
533     //
534     // These optimizations require heap dumping and PreloadSharedClasses, or else
535     // the classes of some archived heap objects may be replaced at runtime.
536     ArchiveInvokeDynamic = false;
537     ArchivePackages = false;
538   }
539 
540   if (!ArchiveInvokeDynamic) {
541     ArchiveReflectionData = false; // reflection data use LambdaForm classes
542   }
543 
544   return true;
545 }
546 bool CDSConfig::is_dumping_classic_static_archive() {
547   return _is_dumping_static_archive && CacheDataStore == nullptr && CDSPreimage == nullptr;
548 }
549 
550 bool CDSConfig::is_dumping_preimage_static_archive() {
551   return _is_dumping_static_archive && CacheDataStore != nullptr && CDSPreimage == nullptr;
552 }
553 
554 bool CDSConfig::is_dumping_final_static_archive() {
555   if (CDSPreimage != nullptr) {
556     assert(CacheDataStore != nullptr, "must be"); // should have been properly initialized by arguments.cpp
557   }
558 
559   // Note: _is_dumping_static_archive is false! // FIXME -- refactor this so it makes more sense!
560   return CacheDataStore != nullptr && CDSPreimage != nullptr;
561 }
562 
563 bool CDSConfig::is_dumping_regenerated_lambdaform_invokers() {
564   if (is_dumping_final_static_archive()) {
565     // Not yet supported in new workflow -- the training data may point
566     // to a method in a lambdaform holder class that was not regenerated
567     // due to JDK-8318064.
568     return false;
569   } else {
570     return is_dumping_archive();
571   }
572 }
573 
574 bool CDSConfig::is_tracing_dynamic_proxy() {
575   return ClassListWriter::is_enabled() || is_dumping_preimage_static_archive();
576 }
577 
578 // Preserve all states that were examined used during dumptime verification, such
579 // that the verification result (pass or fail) cannot be changed at runtime.
580 //
581 // For example, if the verification of ik requires that class A must be a subtype of B,
582 // then this relationship between A and B cannot be changed at runtime. I.e., the app
583 // cannot load alternative versions of A and B such that A is not a subtype of B.
584 bool CDSConfig::preserve_all_dumptime_verification_states(const InstanceKlass* ik) {
585   return PreloadSharedClasses && SystemDictionaryShared::is_builtin(ik);
586 }
587 
588 bool CDSConfig::is_using_archive() {
589   return UseSharedSpaces; // TODO: UseSharedSpaces will be eventually replaced by CDSConfig::is_using_archive()
590 }
591 
592 bool CDSConfig::is_logging_lambda_form_invokers() {
593   return ClassListWriter::is_enabled() || is_dumping_dynamic_archive() || is_dumping_preimage_static_archive();
594 }
595 
596 void CDSConfig::stop_using_optimized_module_handling() {
597   _is_using_optimized_module_handling = false;
598   _is_dumping_full_module_graph = false; // This requires is_using_optimized_module_handling()
599   _is_using_full_module_graph = false; // This requires is_using_optimized_module_handling()
600 }
601 
602 #if INCLUDE_CDS_JAVA_HEAP
603 bool CDSConfig::is_dumping_heap() {
604   return is_dumping_static_archive() && !is_dumping_preimage_static_archive()
605     && HeapShared::can_write();
606 }
607 
608 bool CDSConfig::is_loading_heap() {
609   return ArchiveHeapLoader::is_in_use();
610 }
611 
612 bool CDSConfig::is_using_full_module_graph() {
613   if (ClassLoaderDataShared::is_full_module_graph_loaded()) {
614     return true;
615   }
616 
617   if (!_is_using_full_module_graph) {
618     return false;
619   }
620 
621   if (UseSharedSpaces && ArchiveHeapLoader::can_use()) {
622     // Classes used by the archived full module graph are loaded in JVMTI early phase.
623     assert(!(JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()),
624            "CDS should be disabled if early class hooks are enabled");
625     return true;
626   } else {
627     _is_using_full_module_graph = false;
628     return false;
629   }
630 }
631 
632 void CDSConfig::stop_dumping_full_module_graph(const char* reason) {
633   if (_is_dumping_full_module_graph) {
634     _is_dumping_full_module_graph = false;
635     if (reason != nullptr) {
636       log_info(cds)("full module graph cannot be dumped: %s", reason);
637     }
638   }
639 }
640 
641 void CDSConfig::stop_using_full_module_graph(const char* reason) {
642   assert(!ClassLoaderDataShared::is_full_module_graph_loaded(), "you call this function too late!");
643   if (_is_using_full_module_graph) {
644     _is_using_full_module_graph = false;
645     if (reason != nullptr) {
646       log_info(cds)("full module graph cannot be loaded: %s", reason);
647     }
648   }
649 }
650 
651 bool CDSConfig::is_loading_invokedynamic() {
652   return UseSharedSpaces && is_loading_heap() && _is_loading_invokedynamic;
653 }
654 
655 bool CDSConfig::is_dumping_dynamic_proxy() {
656   return is_dumping_full_module_graph() && is_dumping_invokedynamic();
657 }
658 
659 bool CDSConfig::is_initing_classes_at_dump_time() {
660   return is_dumping_heap() && PreloadSharedClasses;
661 }
662 
663 bool CDSConfig::is_dumping_invokedynamic() {
664   return ArchiveInvokeDynamic && is_dumping_heap();
665 }
666 
667 bool CDSConfig::is_dumping_packages() {
668   return ArchivePackages && is_dumping_heap();
669 }
670 
671 bool CDSConfig::is_loading_packages() {
672   return UseSharedSpaces && is_loading_heap() && _is_loading_packages;
673 }
674 #endif // INCLUDE_CDS_JAVA_HEAP
675 
676 // This is allowed by default. We disable it only in the final image dump before the
677 // metadata and heap are dumped.
678 static bool _is_dumping_cached_code = true;
679 
680 bool CDSConfig::is_dumping_cached_code() {
681   return _is_dumping_cached_code;
682 }
683 
684 void CDSConfig::disable_dumping_cached_code() {
685   _is_dumping_cached_code = false;
686 }
687 
688 void CDSConfig::enable_dumping_cached_code() {
689   _is_dumping_cached_code = true;
690 }
--- EOF ---