1 /*
  2  * Copyright (c) 2023, 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_CDS_CDSCONFIG_HPP
 26 #define SHARE_CDS_CDSCONFIG_HPP
 27 
 28 #include "memory/allStatic.hpp"
 29 #include "runtime/arguments.hpp"
 30 #include "utilities/globalDefinitions.hpp"
 31 #include "utilities/macros.hpp"
 32 
 33 class JavaThread;
 34 
 35 class CDSConfig : public AllStatic {
 36 #if INCLUDE_CDS
 37   static bool _is_dumping_static_archive;
 38   static bool _is_dumping_preimage_static_archive;
 39   static bool _is_dumping_final_static_archive;
 40   static bool _is_dumping_dynamic_archive;
 41   static bool _is_using_optimized_module_handling;
 42   static bool _is_dumping_full_module_graph;
 43   static bool _is_using_full_module_graph;
 44   static bool _has_aot_linked_classes;
 45 
 46   static bool _module_patching_disables_cds;
 47   static bool _java_base_module_patching_disables_cds;
 48 
 49   const static char* _default_archive_path;
 50   const static char* _input_static_archive_path;
 51   const static char* _input_dynamic_archive_path;
 52   const static char* _output_archive_path;
 53 
 54   static bool  _old_cds_flags_used;
 55   static bool  _new_aot_flags_used;
 56   static bool  _disable_heap_dumping;
 57 
 58   static JavaThread* _dumper_thread;
 59 #endif
 60 
 61   static void extract_archive_paths(const char* archive_path,
 62                                     const char** base_archive_path,
 63                                     const char** top_archive_path);
 64   static int num_archive_paths(const char* path_spec);
 65   static void check_flag_single_path(const char* flag_name, const char* value);
 66 
 67   // Checks before Arguments::apply_ergo()
 68   static void check_new_flag(bool new_flag_is_default, const char* new_flag_name);
 69   static void check_aot_flags();
 70   static void check_aotmode_off();
 71   static void check_aotmode_auto_or_on();
 72   static void check_aotmode_record();
 73   static void check_aotmode_create();
 74   static void check_unsupported_dumping_module_options();
 75 
 76   // Called after Arguments::apply_ergo() has started
 77   static void ergo_init_classic_archive_paths();
 78   static void ergo_init_aot_paths();
 79 
 80 public:
 81   // Used by jdk.internal.misc.CDS.getCDSConfigStatus();
 82   static const int IS_DUMPING_ARCHIVE              = 1 << 0;
 83   static const int IS_DUMPING_METHOD_HANDLES       = 1 << 1;
 84   static const int IS_DUMPING_STATIC_ARCHIVE       = 1 << 2;
 85   static const int IS_LOGGING_LAMBDA_FORM_INVOKERS = 1 << 3;
 86   static const int IS_USING_ARCHIVE                = 1 << 4;
 87 
 88   static int get_status() NOT_CDS_RETURN_(0);
 89 
 90   // Initialization and command-line checking
 91   static void ergo_initialize() NOT_CDS_RETURN;
 92   static void set_old_cds_flags_used()                       { CDS_ONLY(_old_cds_flags_used = true); }
 93   static bool old_cds_flags_used()                           { return CDS_ONLY(_old_cds_flags_used) NOT_CDS(false); }
 94   static bool new_aot_flags_used()                           { return CDS_ONLY(_new_aot_flags_used) NOT_CDS(false); }
 95   static void check_internal_module_property(const char* key, const char* value) NOT_CDS_RETURN;
 96   static void check_incompatible_property(const char* key, const char* value) NOT_CDS_RETURN;
 97   static bool has_unsupported_runtime_module_options() NOT_CDS_RETURN_(false);
 98   static bool check_vm_args_consistency(bool mode_flag_cmd_line) NOT_CDS_RETURN_(true);
 99 
100   static bool module_patching_disables_cds() { return CDS_ONLY(_module_patching_disables_cds) NOT_CDS(false); }
101   static void set_module_patching_disables_cds() { CDS_ONLY(_module_patching_disables_cds = true;) }
102   static bool java_base_module_patching_disables_cds() { return CDS_ONLY(_java_base_module_patching_disables_cds) NOT_CDS(false); }
103   static void set_java_base_module_patching_disables_cds() { CDS_ONLY(_java_base_module_patching_disables_cds = true;) }
104   static const char* type_of_archive_being_loaded();
105   static const char* type_of_archive_being_written();
106   static void prepare_for_dumping();
107 
108   // --- Basic CDS features
109 
110   // archive(s) in general
111   static bool is_dumping_archive()                           { return is_dumping_static_archive() || is_dumping_dynamic_archive(); }
112 
113   // input archive(s)
114   static bool is_using_archive()                             NOT_CDS_RETURN_(false);
115 
116   // static_archive
117   static bool is_dumping_static_archive()                    { return CDS_ONLY(_is_dumping_static_archive) NOT_CDS(false); }
118   static void enable_dumping_static_archive()                { CDS_ONLY(_is_dumping_static_archive = true); }
119 
120   // A static CDS archive can be dumped in three modes:
121   //
122   // "classic"   - This is the traditional CDS workflow of
123   //               "java -Xshare:dump -XX:SharedClassListFile=file.txt".
124   //
125   // "preimage"  - This happens when we execute the JEP 483 training run, e.g:
126   //               "java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconfig -cp app.jar App"
127   //               The above command writes app.aotconfig as a "CDS preimage". This
128   //               is a binary file that contains all the classes loaded during the
129   //               training run, plus profiling data (e.g., the resolved constant pool entries).
130   //
131   // "final"     - This happens when we execute the JEP 483 assembly phase, e.g:
132   //               "java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconfig -XX:AOTCache=app.aot -cp app.jar"
133   //               The above command loads all classes from app.aotconfig, perform additional linking,
134   //               and writes app.aot as a "CDS final image" file.
135   //
136   // The main structural difference between "preimage" and "final" is that the preimage
137   // - has a different magic number (0xcafea07c)
138   // - does not have any archived Java heap objects
139   // - does not have aot-linked classes
140   static bool is_dumping_classic_static_archive()            NOT_CDS_RETURN_(false);
141   static bool is_dumping_preimage_static_archive()           NOT_CDS_RETURN_(false);
142   static bool is_dumping_final_static_archive()              NOT_CDS_RETURN_(false);
143 
144   // dynamic_archive
145   static bool is_dumping_dynamic_archive()                   { return CDS_ONLY(_is_dumping_dynamic_archive) NOT_CDS(false); }
146   static void enable_dumping_dynamic_archive(const char* output_path) NOT_CDS_RETURN;
147   static void disable_dumping_dynamic_archive()              { CDS_ONLY(_is_dumping_dynamic_archive = false); }
148 
149   // Misc CDS features
150   static bool allow_only_single_java_thread()                NOT_CDS_RETURN_(false);
151 
152   // This is *Legacy* optimization for lambdas before JEP 483. May be removed in the future.
153   static bool is_dumping_lambdas_in_legacy_mode()            NOT_CDS_RETURN_(false);
154 
155   // optimized_module_handling -- can we skip some expensive operations related to modules?
156   static bool is_using_optimized_module_handling()           { return CDS_ONLY(_is_using_optimized_module_handling) NOT_CDS(false); }
157   static void stop_using_optimized_module_handling()         NOT_CDS_RETURN;
158 
159   static bool is_logging_lambda_form_invokers()              NOT_CDS_RETURN_(false);
160   static bool is_dumping_regenerated_lambdaform_invokers()   NOT_CDS_RETURN_(false);
161 
162   static bool is_dumping_aot_linked_classes()                NOT_CDS_JAVA_HEAP_RETURN_(false);
163   static bool is_using_aot_linked_classes()                  NOT_CDS_JAVA_HEAP_RETURN_(false);
164   static void set_has_aot_linked_classes(bool has_aot_linked_classes) NOT_CDS_JAVA_HEAP_RETURN;
165 
166   // archive_path
167 
168   // Points to the classes.jsa in $JAVA_HOME (could be input or output)
169   static const char* default_archive_path()                  NOT_CDS_RETURN_(nullptr);
170   static const char* input_static_archive_path()             { return CDS_ONLY(_input_static_archive_path) NOT_CDS(nullptr); }
171   static const char* input_dynamic_archive_path()            { return CDS_ONLY(_input_dynamic_archive_path) NOT_CDS(nullptr); }
172   static const char* output_archive_path()                   { return CDS_ONLY(_output_archive_path) NOT_CDS(nullptr); }
173 
174   // --- Archived java objects
175 
176   static bool are_vm_options_incompatible_with_dumping_heap() NOT_CDS_JAVA_HEAP_RETURN_(true);
177   static void log_reasons_for_not_dumping_heap();
178 
179   static void disable_heap_dumping()                         { CDS_ONLY(_disable_heap_dumping = true); }
180   static bool is_dumping_heap()                              NOT_CDS_JAVA_HEAP_RETURN_(false);
181   static bool is_loading_heap()                              NOT_CDS_JAVA_HEAP_RETURN_(false);
182   static bool is_initing_classes_at_dump_time()              NOT_CDS_JAVA_HEAP_RETURN_(false);
183 
184   static bool is_dumping_invokedynamic()                     NOT_CDS_JAVA_HEAP_RETURN_(false);
185   static bool is_dumping_method_handles()                    NOT_CDS_JAVA_HEAP_RETURN_(false);
186 
187   // full_module_graph (requires optimized_module_handling)
188   static bool is_dumping_full_module_graph()                 { return CDS_ONLY(_is_dumping_full_module_graph) NOT_CDS(false); }
189   static bool is_using_full_module_graph()                   NOT_CDS_JAVA_HEAP_RETURN_(false);
190   static void stop_dumping_full_module_graph(const char* reason = nullptr) NOT_CDS_JAVA_HEAP_RETURN;
191   static void stop_using_full_module_graph(const char* reason = nullptr) NOT_CDS_JAVA_HEAP_RETURN;
192 
193   static bool is_valhalla_preview() {
194     return Arguments::enable_preview() && EnableValhalla;
195   }
196 
197   // Some CDS functions assume that they are called only within a single-threaded context. I.e.,
198   // they are called from:
199   //    - The VM thread (e.g., inside VM_PopulateDumpSharedSpace)
200   //    - The thread that performs prepatory steps before switching to the VM thread
201   // Since these two threads never execute concurrently, we can avoid using locks in these CDS
202   // function. For safety, these functions should assert with CDSConfig::current_thread_is_vm_or_dumper().
203   class DumperThreadMark {
204   public:
205     DumperThreadMark(JavaThread* current);
206     ~DumperThreadMark();
207   };
208 
209   static bool current_thread_is_vm_or_dumper() NOT_CDS_RETURN_(false);
210 };
211 
212 #endif // SHARE_CDS_CDSCONFIG_HPP