< prev index next >

src/hotspot/share/cds/cdsConfig.hpp

Print this page
@@ -27,10 +27,11 @@
  
  #include "memory/allStatic.hpp"
  #include "utilities/globalDefinitions.hpp"
  #include "utilities/macros.hpp"
  
+ class InstanceKlass;
  class JavaThread;
  
  class CDSConfig : public AllStatic {
  #if INCLUDE_CDS
    static bool _is_dumping_static_archive;

@@ -39,18 +40,24 @@
    static bool _is_dumping_dynamic_archive;
    static bool _is_using_optimized_module_handling;
    static bool _is_dumping_full_module_graph;
    static bool _is_using_full_module_graph;
    static bool _has_aot_linked_classes;
+   static bool _is_one_step_training;
+   static bool _has_temp_aot_config_file;
+   static bool _is_loading_packages;
+   static bool _is_loading_protection_domains;
+   static bool _is_security_manager_allowed;
  
    const static char* _default_archive_path;
    const static char* _input_static_archive_path;
    const static char* _input_dynamic_archive_path;
    const static char* _output_archive_path;
  
    static bool  _old_cds_flags_used;
    static bool  _new_aot_flags_used;
+   static bool  _experimental_leyden_flags_used;
    static bool  _disable_heap_dumping;
  
    static JavaThread* _dumper_thread;
  #endif
  

@@ -65,35 +72,42 @@
    static void check_aot_flags();
    static void check_aotmode_off();
    static void check_aotmode_auto_or_on();
    static void check_aotmode_record();
    static void check_aotmode_create();
+   static void setup_compiler_args();
+   static bool setup_experimental_leyden_workflow(bool xshare_auto_cmd_line); // Deprecated -- to be removed
    static void check_unsupported_dumping_module_options();
  
    // Called after Arguments::apply_ergo() has started
    static void ergo_init_classic_archive_paths();
    static void ergo_init_aot_paths();
+   static void ergo_init_experimental_leyden_paths();
  
  public:
    // Used by jdk.internal.misc.CDS.getCDSConfigStatus();
    static const int IS_DUMPING_ARCHIVE              = 1 << 0;
    static const int IS_DUMPING_METHOD_HANDLES       = 1 << 1;
    static const int IS_DUMPING_STATIC_ARCHIVE       = 1 << 2;
    static const int IS_LOGGING_LAMBDA_FORM_INVOKERS = 1 << 3;
    static const int IS_USING_ARCHIVE                = 1 << 4;
- 
+   static const int IS_DUMPING_HEAP                 = 1 << 5;
+   static const int IS_LOGGING_DYNAMIC_PROXIES      = 1 << 6;
+   static const int IS_DUMPING_PACKAGES             = 1 << 7;
+   static const int IS_DUMPING_PROTECTION_DOMAINS   = 1 << 8;
    static int get_status() NOT_CDS_RETURN_(0);
  
    // Initialization and command-line checking
    static void ergo_initialize() NOT_CDS_RETURN;
    static void set_old_cds_flags_used()                       { CDS_ONLY(_old_cds_flags_used = true); }
    static bool old_cds_flags_used()                           { return CDS_ONLY(_old_cds_flags_used) NOT_CDS(false); }
    static bool new_aot_flags_used()                           { return CDS_ONLY(_new_aot_flags_used) NOT_CDS(false); }
+   static bool experimental_leyden_flags_used()               { return CDS_ONLY(_experimental_leyden_flags_used) NOT_CDS(false); }
    static void check_internal_module_property(const char* key, const char* value) NOT_CDS_RETURN;
    static void check_incompatible_property(const char* key, const char* value) NOT_CDS_RETURN;
    static bool has_unsupported_runtime_module_options() NOT_CDS_RETURN_(false);
-   static bool check_vm_args_consistency(bool patch_mod_javabase, bool mode_flag_cmd_line) NOT_CDS_RETURN_(true);
+   static bool check_vm_args_consistency(bool patch_mod_javabase, bool mode_flag_cmd_line, bool xshare_auto_cmd_line) NOT_CDS_RETURN_(true);
    static const char* type_of_archive_being_loaded();
    static const char* type_of_archive_being_written();
    static void prepare_for_dumping();
  
    // --- Basic CDS features

@@ -103,13 +117,15 @@
  
    // input archive(s)
    static bool is_using_archive()                             NOT_CDS_RETURN_(false);
  
    // static_archive
-   static bool is_dumping_static_archive()                    { return CDS_ONLY(_is_dumping_static_archive) NOT_CDS(false); }
+   static bool is_dumping_static_archive()                    { return (CDS_ONLY(_is_dumping_static_archive) NOT_CDS(false))
+                                                                     || is_dumping_final_static_archive(); }
    static void enable_dumping_static_archive()                { CDS_ONLY(_is_dumping_static_archive = true); }
  
+ 
    // A static CDS archive can be dumped in three modes:
    //
    // "classic"   - This is the traditional CDS workflow of
    //               "java -Xshare:dump -XX:SharedClassListFile=file.txt".
    //

@@ -126,22 +142,27 @@
    //
    // The main structural difference between "preimage" and "final" is that the preimage
    // - has a different magic number (0xcafea07c)
    // - does not have any archived Java heap objects
    // - does not have aot-linked classes
-   static bool is_dumping_classic_static_archive()            NOT_CDS_RETURN_(false);
-   static bool is_dumping_preimage_static_archive()           NOT_CDS_RETURN_(false);
-   static bool is_dumping_final_static_archive()              NOT_CDS_RETURN_(false);
+   static bool is_dumping_classic_static_archive()                NOT_CDS_RETURN_(false);
+   static bool is_dumping_preimage_static_archive()               NOT_CDS_RETURN_(false);
+   static bool is_dumping_preimage_static_archive_with_triggers() NOT_CDS_RETURN_(false); 
+   static bool is_dumping_final_static_archive()                  NOT_CDS_RETURN_(false);
  
    // dynamic_archive
    static bool is_dumping_dynamic_archive()                   { return CDS_ONLY(_is_dumping_dynamic_archive) NOT_CDS(false); }
    static void enable_dumping_dynamic_archive(const char* output_path) NOT_CDS_RETURN;
    static void disable_dumping_dynamic_archive()              { CDS_ONLY(_is_dumping_dynamic_archive = false); }
  
    // Misc CDS features
+   static bool preserve_all_dumptime_verification_states(const InstanceKlass* ik);
    static bool allow_only_single_java_thread()                NOT_CDS_RETURN_(false);
  
+   static bool is_one_step_training()                         { return CDS_ONLY(_is_one_step_training) NOT_CDS(false); }
+   static bool has_temp_aot_config_file()                     { return CDS_ONLY(_has_temp_aot_config_file) NOT_CDS(false); }
+ 
    // This is *Legacy* optimization for lambdas before JEP 483. May be removed in the future.
    static bool is_dumping_lambdas_in_legacy_mode()            NOT_CDS_RETURN_(false);
  
    // optimized_module_handling -- can we skip some expensive operations related to modules?
    static bool is_using_optimized_module_handling()           { return CDS_ONLY(_is_using_optimized_module_handling) NOT_CDS(false); }

@@ -173,16 +194,40 @@
    static bool is_initing_classes_at_dump_time()              NOT_CDS_JAVA_HEAP_RETURN_(false);
  
    static bool is_dumping_invokedynamic()                     NOT_CDS_JAVA_HEAP_RETURN_(false);
    static bool is_dumping_method_handles()                    NOT_CDS_JAVA_HEAP_RETURN_(false);
  
+   static bool is_dumping_packages()                          NOT_CDS_JAVA_HEAP_RETURN_(false);
+   static bool is_loading_packages()                          NOT_CDS_JAVA_HEAP_RETURN_(false);
+   static void set_is_loading_packages()                      { CDS_JAVA_HEAP_ONLY(_is_loading_packages = true); }
+ 
+   static bool is_dumping_protection_domains()                NOT_CDS_JAVA_HEAP_RETURN_(false);
+   static bool is_loading_protection_domains()                NOT_CDS_JAVA_HEAP_RETURN_(false);
+   static void set_is_loading_protection_domains()            { CDS_JAVA_HEAP_ONLY(_is_loading_protection_domains = true); }
+ 
+   static bool is_dumping_reflection_data()                   NOT_CDS_JAVA_HEAP_RETURN_(false);
+ 
+   static bool is_dumping_dynamic_proxies()                   NOT_CDS_JAVA_HEAP_RETURN_(false);
+   static bool is_logging_dynamic_proxies()                   NOT_CDS_RETURN_(false);
+ 
    // full_module_graph (requires optimized_module_handling)
    static bool is_dumping_full_module_graph()                 { return CDS_ONLY(_is_dumping_full_module_graph) NOT_CDS(false); }
    static bool is_using_full_module_graph()                   NOT_CDS_JAVA_HEAP_RETURN_(false);
    static void stop_dumping_full_module_graph(const char* reason = nullptr) NOT_CDS_JAVA_HEAP_RETURN;
    static void stop_using_full_module_graph(const char* reason = nullptr) NOT_CDS_JAVA_HEAP_RETURN;
  
+   // --- AOT compiler
+ 
+   static bool is_dumping_cached_code()                       NOT_CDS_RETURN_(false);
+   static void disable_dumping_cached_code()                  NOT_CDS_RETURN;
+   static void enable_dumping_cached_code()                   NOT_CDS_RETURN;
+ 
+   static bool is_dumping_adapters()                          NOT_CDS_RETURN_(false);
+ 
+   // Are we using the (to be deprecated) -XX:CacheDataStore workflow?
+   static bool is_experimental_leyden_workflow()              NOT_CDS_RETURN_(false);
+ 
    // Some CDS functions assume that they are called only within a single-threaded context. I.e.,
    // they are called from:
    //    - The VM thread (e.g., inside VM_PopulateDumpSharedSpace)
    //    - The thread that performs prepatory steps before switching to the VM thread
    // Since these two threads never execute concurrently, we can avoid using locks in these CDS
< prev index next >