1 /*
  2  * Copyright (c) 2016, 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 #include "code/codeCache.hpp"
 26 #include "compiler/compilerDefinitions.inline.hpp"
 27 #include "interpreter/invocationCounter.hpp"
 28 #include "jvm_io.h"
 29 #include "runtime/arguments.hpp"
 30 #include "runtime/continuation.hpp"
 31 #include "runtime/flags/jvmFlag.hpp"
 32 #include "runtime/flags/jvmFlagAccess.hpp"
 33 #include "runtime/flags/jvmFlagConstraintsCompiler.hpp"
 34 #include "runtime/flags/jvmFlagLimit.hpp"
 35 #include "runtime/globals.hpp"
 36 #include "runtime/globals_extension.hpp"
 37 #include "utilities/defaultStream.hpp"
 38 
 39 const char* compilertype2name_tab[compiler_number_of_types] = {
 40   "",
 41   "c1",
 42   "c2",
 43   "jvmci"
 44 };
 45 
 46 CompilationModeFlag::Mode CompilationModeFlag::_mode = CompilationModeFlag::Mode::NORMAL;
 47 
 48 static void print_mode_unavailable(const char* mode_name, const char* reason) {
 49   warning("%s compilation mode unavailable because %s.", mode_name, reason);
 50 }
 51 
 52 bool CompilationModeFlag::initialize() {
 53   _mode = Mode::NORMAL;
 54   // During parsing we want to be very careful not to use any methods of CompilerConfig that depend on
 55   // CompilationModeFlag.
 56   if (CompilationMode != nullptr) {
 57     if (strcmp(CompilationMode, "default") == 0 || strcmp(CompilationMode, "normal") == 0) {
 58       assert(_mode == Mode::NORMAL, "Precondition");
 59     } else if (strcmp(CompilationMode, "quick-only") == 0) {
 60       if (!CompilerConfig::has_c1()) {
 61         print_mode_unavailable("quick-only", "there is no c1 present");
 62       } else {
 63         _mode = Mode::QUICK_ONLY;
 64       }
 65     } else if (strcmp(CompilationMode, "high-only") == 0) {
 66       if (!CompilerConfig::has_c2() && !CompilerConfig::is_jvmci_compiler()) {
 67         print_mode_unavailable("high-only", "there is no c2 or jvmci compiler present");
 68       } else {
 69         _mode = Mode::HIGH_ONLY;
 70       }
 71     } else if (strcmp(CompilationMode, "high-only-quick-internal") == 0) {
 72       if (!CompilerConfig::has_c1() || !CompilerConfig::is_jvmci_compiler()) {
 73         print_mode_unavailable("high-only-quick-internal", "there is no c1 and jvmci compiler present");
 74       } else {
 75         _mode = Mode::HIGH_ONLY_QUICK_INTERNAL;
 76       }
 77     } else {
 78       print_error();
 79       return false;
 80     }
 81   }
 82 
 83   // Now that the flag is parsed, we can use any methods of CompilerConfig.
 84   if (normal()) {
 85     if (CompilerConfig::is_c1_simple_only()) {
 86       _mode = Mode::QUICK_ONLY;
 87     } else if (CompilerConfig::is_c2_or_jvmci_compiler_only()) {
 88       _mode = Mode::HIGH_ONLY;
 89     } else if (CompilerConfig::is_jvmci_compiler_enabled() && CompilerConfig::is_c1_enabled() && !TieredCompilation) {
 90       warning("Disabling tiered compilation with non-native JVMCI compiler is not recommended, "
 91               "disabling intermediate compilation levels instead. ");
 92       _mode = Mode::HIGH_ONLY_QUICK_INTERNAL;
 93     }
 94   }
 95   return true;
 96 }
 97 
 98 void CompilationModeFlag::print_error() {
 99   jio_fprintf(defaultStream::error_stream(), "Unsupported compilation mode '%s', available modes are:", CompilationMode);
100   bool comma = false;
101   if (CompilerConfig::has_c1()) {
102     jio_fprintf(defaultStream::error_stream(), "%s quick-only", comma ? "," : "");
103     comma = true;
104   }
105   if (CompilerConfig::has_c2() || CompilerConfig::has_jvmci()) {
106     jio_fprintf(defaultStream::error_stream(), "%s high-only", comma ? "," : "");
107     comma = true;
108   }
109   if (CompilerConfig::has_c1() && CompilerConfig::has_jvmci()) {
110     jio_fprintf(defaultStream::error_stream(), "%s high-only-quick-internal", comma ? "," : "");
111     comma = true;
112   }
113   jio_fprintf(defaultStream::error_stream(), "\n");
114 }
115 
116 // Returns threshold scaled with CompileThresholdScaling
117 intx CompilerConfig::scaled_compile_threshold(intx threshold) {
118   return scaled_compile_threshold(threshold, CompileThresholdScaling);
119 }
120 
121 // Returns freq_log scaled with CompileThresholdScaling
122 intx CompilerConfig::scaled_freq_log(intx freq_log) {
123   return scaled_freq_log(freq_log, CompileThresholdScaling);
124 }
125 
126 // For XXXThreshold flags, which all have a valid range of [0 .. max_jint]
127 intx CompilerConfig::jvmflag_scaled_compile_threshold(intx threshold) {
128   return MAX2((intx)0, MIN2(scaled_compile_threshold(threshold), (intx)max_jint));
129 }
130 
131 // For XXXNotifyFreqLog flags, which all have a valid range of [0 .. 30]
132 intx CompilerConfig::jvmflag_scaled_freq_log(intx freq_log) {
133   return MAX2((intx)0, MIN2(scaled_freq_log(freq_log), (intx)30));
134 }
135 
136 // Returns threshold scaled with the value of scale.
137 // If scale < 0.0, threshold is returned without scaling.
138 intx CompilerConfig::scaled_compile_threshold(intx threshold, double scale) {
139   assert(threshold >= 0, "must be");
140   if (scale == 1.0 || scale < 0.0) {
141     return threshold;
142   } else {
143     double v = threshold * scale;
144     assert(v >= 0, "must be");
145     if (g_isnan(v) || !g_isfinite(v)) {
146       return max_intx;
147     }
148     int exp;
149     (void) frexp(v, &exp);
150     int max_exp = sizeof(intx) * BitsPerByte - 1;
151     if (exp > max_exp) {
152       return max_intx;
153     }
154     intx r = (intx)(v);
155     assert(r >= 0, "must be");
156     return r;
157   }
158 }
159 
160 // Returns freq_log scaled with the value of scale.
161 // Returned values are in the range of [0, InvocationCounter::number_of_count_bits + 1].
162 // If scale < 0.0, freq_log is returned without scaling.
163 intx CompilerConfig::scaled_freq_log(intx freq_log, double scale) {
164   // Check if scaling is necessary or if negative value was specified.
165   if (scale == 1.0 || scale < 0.0) {
166     return freq_log;
167   }
168   // Check values to avoid calculating log2 of 0.
169   if (scale == 0.0 || freq_log == 0) {
170     return 0;
171   }
172   // Determine the maximum notification frequency value currently supported.
173   // The largest mask value that the interpreter/C1 can handle is
174   // of length InvocationCounter::number_of_count_bits. Mask values are always
175   // one bit shorter then the value of the notification frequency. Set
176   // max_freq_bits accordingly.
177   int max_freq_bits = InvocationCounter::number_of_count_bits + 1;
178   intx scaled_freq = scaled_compile_threshold((intx)1 << freq_log, scale);
179 
180   if (scaled_freq == 0) {
181     // Return 0 right away to avoid calculating log2 of 0.
182     return 0;
183   } else {
184     return MIN2(log2i(scaled_freq), max_freq_bits);
185   }
186 }
187 
188 void CompilerConfig::set_client_emulation_mode_flags() {
189   assert(has_c1(), "Must have C1 compiler present");
190   CompilationModeFlag::set_quick_only();
191 
192   FLAG_SET_ERGO(ProfileInterpreter, false);
193 #if INCLUDE_JVMCI
194   FLAG_SET_ERGO(EnableJVMCI, false);
195   FLAG_SET_ERGO(UseJVMCICompiler, false);
196 #endif
197   if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) {
198     FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
199   }
200   if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
201     FLAG_SET_ERGO(InitialCodeCacheSize, 160*K);
202   }
203   if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
204     FLAG_SET_ERGO(ReservedCodeCacheSize, 32*M);
205   }
206   if (FLAG_IS_DEFAULT(NonProfiledCodeHeapSize)) {
207     FLAG_SET_ERGO(NonProfiledCodeHeapSize, 27*M);
208   }
209   if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize)) {
210     FLAG_SET_ERGO(ProfiledCodeHeapSize, 0);
211   }
212   if (FLAG_IS_DEFAULT(NonNMethodCodeHeapSize)) {
213     FLAG_SET_ERGO(NonNMethodCodeHeapSize, 5*M);
214   }
215   if (FLAG_IS_DEFAULT(CodeCacheExpansionSize)) {
216     FLAG_SET_ERGO(CodeCacheExpansionSize, 32*K);
217   }
218   if (FLAG_IS_DEFAULT(MaxRAM)) {
219     // Do not use FLAG_SET_ERGO to update MaxRAM, as this will impact
220     // heap setting done based on available phys_mem (see Arguments::set_heap_size).
221     FLAG_SET_DEFAULT(MaxRAM, 1ULL*G);
222   }
223   if (FLAG_IS_DEFAULT(CICompilerCount)) {
224     FLAG_SET_ERGO(CICompilerCount, 1);
225   }
226 }
227 
228 bool CompilerConfig::is_compilation_mode_selected() {
229   return !FLAG_IS_DEFAULT(TieredCompilation) ||
230          !FLAG_IS_DEFAULT(TieredStopAtLevel) ||
231          !FLAG_IS_DEFAULT(CompilationMode)
232          JVMCI_ONLY(|| !FLAG_IS_DEFAULT(EnableJVMCI)
233                     || !FLAG_IS_DEFAULT(UseJVMCICompiler));
234 }
235 
236 static bool check_legacy_flags() {
237   JVMFlag* compile_threshold_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(CompileThreshold));
238   if (JVMFlagAccess::check_constraint(compile_threshold_flag, JVMFlagLimit::get_constraint(compile_threshold_flag)->constraint_func(), false) != JVMFlag::SUCCESS) {
239     return false;
240   }
241   JVMFlag* on_stack_replace_percentage_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(OnStackReplacePercentage));
242   if (JVMFlagAccess::check_constraint(on_stack_replace_percentage_flag, JVMFlagLimit::get_constraint(on_stack_replace_percentage_flag)->constraint_func(), false) != JVMFlag::SUCCESS) {
243     return false;
244   }
245   JVMFlag* interpreter_profile_percentage_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(InterpreterProfilePercentage));
246   if (JVMFlagAccess::check_range(interpreter_profile_percentage_flag, false) != JVMFlag::SUCCESS) {
247     return false;
248   }
249   return true;
250 }
251 
252 void CompilerConfig::set_legacy_emulation_flags() {
253   // Any legacy flags set?
254   if (!FLAG_IS_DEFAULT(CompileThreshold)         ||
255       !FLAG_IS_DEFAULT(OnStackReplacePercentage) ||
256       !FLAG_IS_DEFAULT(InterpreterProfilePercentage)) {
257     if (CompilerConfig::is_c1_only() || CompilerConfig::is_c2_or_jvmci_compiler_only()) {
258       // This function is called before these flags are validated. In order to not confuse the user with extraneous
259       // error messages, we check the validity of these flags here and bail out if any of them are invalid.
260       if (!check_legacy_flags()) {
261         return;
262       }
263       // Note, we do not scale CompileThreshold before this because the tiered flags are
264       // all going to be scaled further in set_compilation_policy_flags().
265       const intx threshold = CompileThreshold;
266       const intx profile_threshold = threshold * InterpreterProfilePercentage / 100;
267       const intx osr_threshold = threshold * OnStackReplacePercentage / 100;
268       const intx osr_profile_threshold = osr_threshold * InterpreterProfilePercentage / 100;
269 
270       const intx threshold_log = log2i_graceful(CompilerConfig::is_c1_only() ? threshold : profile_threshold);
271       const intx osr_threshold_log = log2i_graceful(CompilerConfig::is_c1_only() ? osr_threshold : osr_profile_threshold);
272 
273       if (Tier0InvokeNotifyFreqLog > threshold_log) {
274         FLAG_SET_ERGO(Tier0InvokeNotifyFreqLog, MAX2<intx>(0, threshold_log));
275       }
276 
277       // Note: Emulation oddity. The legacy policy limited the amount of callbacks from the
278       // interpreter for backedge events to once every 1024 counter increments.
279       // We simulate this behavior by limiting the backedge notification frequency to be
280       // at least 2^10.
281       if (Tier0BackedgeNotifyFreqLog > osr_threshold_log) {
282         FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, MAX2<intx>(10, osr_threshold_log));
283       }
284       // Adjust the tiered policy flags to approximate the legacy behavior.
285       FLAG_SET_ERGO(Tier3InvocationThreshold, threshold);
286       FLAG_SET_ERGO(Tier3MinInvocationThreshold, threshold);
287       FLAG_SET_ERGO(Tier3CompileThreshold, threshold);
288       FLAG_SET_ERGO(Tier3BackEdgeThreshold, osr_threshold);
289       if (CompilerConfig::is_c2_or_jvmci_compiler_only()) {
290         FLAG_SET_ERGO(Tier4InvocationThreshold, threshold);
291         FLAG_SET_ERGO(Tier4MinInvocationThreshold, threshold);
292         FLAG_SET_ERGO(Tier4CompileThreshold, threshold);
293         FLAG_SET_ERGO(Tier4BackEdgeThreshold, osr_threshold);
294         FLAG_SET_ERGO(Tier0ProfilingStartPercentage, InterpreterProfilePercentage);
295       }
296     } else {
297       // Normal tiered mode, ignore legacy flags
298     }
299   }
300   // Scale CompileThreshold
301   // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged.
302   if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0 && CompileThreshold > 0) {
303     intx scaled_value = scaled_compile_threshold(CompileThreshold);
304     if (CompileThresholdConstraintFunc(scaled_value, true) != JVMFlag::VIOLATES_CONSTRAINT) {
305       FLAG_SET_ERGO(CompileThreshold, scaled_value);
306     }
307   }
308 }
309 
310 
311 void CompilerConfig::set_compilation_policy_flags() {
312   if (is_tiered()) {
313     // Increase the code cache size - tiered compiles a lot more.
314     if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
315       FLAG_SET_ERGO(ReservedCodeCacheSize,
316                     MIN2(CODE_CACHE_DEFAULT_LIMIT, (size_t)ReservedCodeCacheSize * 5));
317     }
318     // Enable SegmentedCodeCache if tiered compilation is enabled, ReservedCodeCacheSize >= 240M
319     // and the code cache contains at least 8 pages (segmentation disables advantage of huge pages).
320     if (FLAG_IS_DEFAULT(SegmentedCodeCache) && ReservedCodeCacheSize >= 240*M &&
321         8 * CodeCache::page_size() <= ReservedCodeCacheSize) {
322       FLAG_SET_ERGO(SegmentedCodeCache, true);
323     }
324     if (Arguments::is_compiler_only()) { // -Xcomp
325       // Be much more aggressive in tiered mode with -Xcomp and exercise C2 more.
326       // We will first compile a level 3 version (C1 with full profiling), then do one invocation of it and
327       // compile a level 4 (C2) and then continue executing it.
328       if (FLAG_IS_DEFAULT(Tier3InvokeNotifyFreqLog)) {
329         FLAG_SET_CMDLINE(Tier3InvokeNotifyFreqLog, 0);
330       }
331       if (FLAG_IS_DEFAULT(Tier4InvocationThreshold)) {
332         FLAG_SET_CMDLINE(Tier4InvocationThreshold, 0);
333       }
334     }
335   }
336 
337   // Current Leyden implementation requires SegmentedCodeCache: the archive-backed code
338   // cache would be initialized only then. Force SegmentedCodeCache if we are loading/storing
339   // cached code. TODO: Resolve this in code cache initialization code.
340   if (!SegmentedCodeCache && (LoadCachedCode || StoreCachedCode)) {
341     FLAG_SET_ERGO(SegmentedCodeCache, true);
342   }
343 
344   if (CompileThresholdScaling < 0) {
345     vm_exit_during_initialization("Negative value specified for CompileThresholdScaling", nullptr);
346   }
347 
348   if (CompilationModeFlag::disable_intermediate()) {
349     if (FLAG_IS_DEFAULT(Tier0ProfilingStartPercentage)) {
350       FLAG_SET_DEFAULT(Tier0ProfilingStartPercentage, 33);
351     }
352 
353     if (FLAG_IS_DEFAULT(Tier4InvocationThreshold)) {
354       FLAG_SET_DEFAULT(Tier4InvocationThreshold, 5000);
355     }
356     if (FLAG_IS_DEFAULT(Tier4MinInvocationThreshold)) {
357       FLAG_SET_DEFAULT(Tier4MinInvocationThreshold, 600);
358     }
359     if (FLAG_IS_DEFAULT(Tier4CompileThreshold)) {
360       FLAG_SET_DEFAULT(Tier4CompileThreshold, 10000);
361     }
362     if (FLAG_IS_DEFAULT(Tier4BackEdgeThreshold)) {
363       FLAG_SET_DEFAULT(Tier4BackEdgeThreshold, 15000);
364     }
365 
366     if (FLAG_IS_DEFAULT(Tier3InvocationThreshold)) {
367       FLAG_SET_DEFAULT(Tier3InvocationThreshold, Tier4InvocationThreshold);
368     }
369     if (FLAG_IS_DEFAULT(Tier3MinInvocationThreshold)) {
370       FLAG_SET_DEFAULT(Tier3MinInvocationThreshold, Tier4MinInvocationThreshold);
371     }
372     if (FLAG_IS_DEFAULT(Tier3CompileThreshold)) {
373       FLAG_SET_DEFAULT(Tier3CompileThreshold, Tier4CompileThreshold);
374     }
375     if (FLAG_IS_DEFAULT(Tier3BackEdgeThreshold)) {
376       FLAG_SET_DEFAULT(Tier3BackEdgeThreshold, Tier4BackEdgeThreshold);
377     }
378 
379   }
380 
381   // Scale tiered compilation thresholds.
382   // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves compilation thresholds unchanged.
383   if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) {
384     FLAG_SET_ERGO(Tier0InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier0InvokeNotifyFreqLog));
385     FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier0BackedgeNotifyFreqLog));
386 
387     FLAG_SET_ERGO(Tier3InvocationThreshold, jvmflag_scaled_compile_threshold(Tier3InvocationThreshold));
388     FLAG_SET_ERGO(Tier3MinInvocationThreshold, jvmflag_scaled_compile_threshold(Tier3MinInvocationThreshold));
389     FLAG_SET_ERGO(Tier3CompileThreshold, jvmflag_scaled_compile_threshold(Tier3CompileThreshold));
390     FLAG_SET_ERGO(Tier3BackEdgeThreshold, jvmflag_scaled_compile_threshold(Tier3BackEdgeThreshold));
391 
392     // Tier2{Invocation,MinInvocation,Compile,Backedge}Threshold should be scaled here
393     // once these thresholds become supported.
394 
395     FLAG_SET_ERGO(Tier2InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier2InvokeNotifyFreqLog));
396     FLAG_SET_ERGO(Tier2BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier2BackedgeNotifyFreqLog));
397 
398     FLAG_SET_ERGO(Tier3InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier3InvokeNotifyFreqLog));
399     FLAG_SET_ERGO(Tier3BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier3BackedgeNotifyFreqLog));
400 
401     FLAG_SET_ERGO(Tier23InlineeNotifyFreqLog, jvmflag_scaled_freq_log(Tier23InlineeNotifyFreqLog));
402 
403     FLAG_SET_ERGO(Tier4InvocationThreshold, jvmflag_scaled_compile_threshold(Tier4InvocationThreshold));
404     FLAG_SET_ERGO(Tier4MinInvocationThreshold, jvmflag_scaled_compile_threshold(Tier4MinInvocationThreshold));
405     FLAG_SET_ERGO(Tier4CompileThreshold, jvmflag_scaled_compile_threshold(Tier4CompileThreshold));
406     FLAG_SET_ERGO(Tier4BackEdgeThreshold, jvmflag_scaled_compile_threshold(Tier4BackEdgeThreshold));
407   }
408 
409 #ifdef COMPILER1
410   // Reduce stack usage due to inlining of methods which require much stack.
411   // (High tier compiler can inline better based on profiling information.)
412   if (FLAG_IS_DEFAULT(C1InlineStackLimit) &&
413       TieredStopAtLevel == CompLevel_full_optimization && !CompilerConfig::is_c1_only()) {
414     FLAG_SET_DEFAULT(C1InlineStackLimit, 5);
415   }
416 #endif
417 
418   if (CompilerConfig::is_tiered() && CompilerConfig::is_c2_enabled()) {
419 #ifdef COMPILER2
420     // Some inlining tuning
421 #if defined(X86) || defined(AARCH64) || defined(RISCV64)
422     if (FLAG_IS_DEFAULT(InlineSmallCode)) {
423       FLAG_SET_DEFAULT(InlineSmallCode, 2500);
424     }
425 #endif
426 #endif // COMPILER2
427   }
428 
429 }
430 
431 #if INCLUDE_JVMCI
432 void CompilerConfig::set_jvmci_specific_flags() {
433   if (UseJVMCICompiler) {
434     if (FLAG_IS_DEFAULT(TypeProfileWidth)) {
435       FLAG_SET_DEFAULT(TypeProfileWidth, 8);
436     }
437     if (FLAG_IS_DEFAULT(TypeProfileLevel)) {
438       FLAG_SET_DEFAULT(TypeProfileLevel, 0);
439     }
440 
441     if (UseJVMCINativeLibrary) {
442       // SVM compiled code requires more stack space
443       if (FLAG_IS_DEFAULT(CompilerThreadStackSize)) {
444         // Duplicate logic in the implementations of os::create_thread
445         // so that we can then double the computed stack size. Once
446         // the stack size requirements of SVM are better understood,
447         // this logic can be pushed down into os::create_thread.
448         int stack_size = CompilerThreadStackSize;
449         if (stack_size == 0) {
450           stack_size = VMThreadStackSize;
451         }
452         if (stack_size != 0) {
453           FLAG_SET_DEFAULT(CompilerThreadStackSize, stack_size * 2);
454         }
455       }
456     } else {
457       // JVMCI needs values not less than defaults
458       if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
459         FLAG_SET_DEFAULT(ReservedCodeCacheSize, MAX2(64*M, ReservedCodeCacheSize));
460       }
461       if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
462         FLAG_SET_DEFAULT(InitialCodeCacheSize, MAX2(16*M, InitialCodeCacheSize));
463       }
464       if (FLAG_IS_DEFAULT(NewSizeThreadIncrease)) {
465         FLAG_SET_DEFAULT(NewSizeThreadIncrease, MAX2(4*K, NewSizeThreadIncrease));
466       }
467       if (FLAG_IS_DEFAULT(Tier3DelayOn)) {
468         // This effectively prevents the compile broker scheduling tier 2
469         // (i.e., limited C1 profiling) compilations instead of tier 3
470         // (i.e., full C1 profiling) compilations when the tier 4 queue
471         // backs up (which is quite likely when using a non-AOT compiled JVMCI
472         // compiler). The observation based on jargraal is that the downside
473         // of skipping full profiling is much worse for performance than the
474         // queue backing up.
475         FLAG_SET_DEFAULT(Tier3DelayOn, 100000);
476       }
477     } // !UseJVMCINativeLibrary
478   } // UseJVMCICompiler
479 }
480 #endif // INCLUDE_JVMCI
481 
482 bool CompilerConfig::check_args_consistency(bool status) {
483   // Check lower bounds of the code cache
484   // Template Interpreter code is approximately 3X larger in debug builds.
485   uint min_code_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3);
486   if (ReservedCodeCacheSize < InitialCodeCacheSize) {
487     jio_fprintf(defaultStream::error_stream(),
488                 "Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n",
489                 ReservedCodeCacheSize/K, InitialCodeCacheSize/K);
490     status = false;
491   } else if (ReservedCodeCacheSize < min_code_cache_size) {
492     jio_fprintf(defaultStream::error_stream(),
493                 "Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\n", ReservedCodeCacheSize/K,
494                 min_code_cache_size/K);
495     status = false;
496   } else if (ReservedCodeCacheSize > CODE_CACHE_SIZE_LIMIT) {
497     // Code cache size larger than CODE_CACHE_SIZE_LIMIT is not supported.
498     jio_fprintf(defaultStream::error_stream(),
499                 "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
500                 CODE_CACHE_SIZE_LIMIT/M);
501     status = false;
502   } else if (NonNMethodCodeHeapSize < min_code_cache_size) {
503     jio_fprintf(defaultStream::error_stream(),
504                 "Invalid NonNMethodCodeHeapSize=%dK. Must be at least %uK.\n", NonNMethodCodeHeapSize/K,
505                 min_code_cache_size/K);
506     status = false;
507   }
508 
509 #ifdef _LP64
510   if (!FLAG_IS_DEFAULT(CICompilerCount) && !FLAG_IS_DEFAULT(CICompilerCountPerCPU) && CICompilerCountPerCPU) {
511     warning("The VM option CICompilerCountPerCPU overrides CICompilerCount.");
512   }
513 #endif
514 
515   if (BackgroundCompilation && ReplayCompiles) {
516     if (!FLAG_IS_DEFAULT(BackgroundCompilation)) {
517       warning("BackgroundCompilation disabled due to ReplayCompiles option.");
518     }
519     FLAG_SET_CMDLINE(BackgroundCompilation, false);
520   }
521 
522   if (CompilerConfig::is_interpreter_only()) {
523     if (UseCompiler) {
524       if (!FLAG_IS_DEFAULT(UseCompiler)) {
525         warning("UseCompiler disabled due to -Xint.");
526       }
527       FLAG_SET_CMDLINE(UseCompiler, false);
528     }
529     if (ProfileInterpreter) {
530       if (!FLAG_IS_DEFAULT(ProfileInterpreter)) {
531         warning("ProfileInterpreter disabled due to -Xint.");
532       }
533       FLAG_SET_CMDLINE(ProfileInterpreter, false);
534     }
535     if (TieredCompilation) {
536       if (!FLAG_IS_DEFAULT(TieredCompilation)) {
537         warning("TieredCompilation disabled due to -Xint.");
538       }
539       FLAG_SET_CMDLINE(TieredCompilation, false);
540     }
541     if (SegmentedCodeCache) {
542       warning("SegmentedCodeCache has no meaningful effect with -Xint");
543       FLAG_SET_DEFAULT(SegmentedCodeCache, false);
544     }
545 #if INCLUDE_JVMCI
546     if (EnableJVMCI || UseJVMCICompiler) {
547       if (!FLAG_IS_DEFAULT(EnableJVMCI) || !FLAG_IS_DEFAULT(UseJVMCICompiler)) {
548         warning("JVMCI Compiler disabled due to -Xint.");
549       }
550       FLAG_SET_CMDLINE(EnableJVMCI, false);
551       FLAG_SET_CMDLINE(UseJVMCICompiler, false);
552     }
553 #endif
554   } else {
555 #if INCLUDE_JVMCI
556     status = status && JVMCIGlobals::check_jvmci_flags_are_consistent();
557 #endif
558   }
559 
560   return status;
561 }
562 
563 void CompilerConfig::ergo_initialize() {
564 #if !COMPILER1_OR_COMPILER2
565   return;
566 #endif
567 
568   if (has_c1()) {
569     if (!is_compilation_mode_selected()) {
570       if (NeverActAsServerClassMachine) {
571         set_client_emulation_mode_flags();
572       }
573     } else if (!has_c2() && !is_jvmci_compiler()) {
574       set_client_emulation_mode_flags();
575     }
576   }
577 
578   set_legacy_emulation_flags();
579   set_compilation_policy_flags();
580 
581 #if INCLUDE_JVMCI
582   // Check that JVMCI supports selected GC.
583   // Should be done after GCConfig::initialize() was called.
584   JVMCIGlobals::check_jvmci_supported_gc();
585 
586   // Do JVMCI specific settings
587   set_jvmci_specific_flags();
588 #endif
589 
590   if (PreloadOnly) {
591     // Disable profiling/counter updates in interpreter and C1.
592     // This effectively disables most of the normal JIT (re-)compilations.
593     FLAG_SET_DEFAULT(ProfileInterpreter, false);
594     FLAG_SET_DEFAULT(UseOnStackReplacement, false);
595     FLAG_SET_DEFAULT(UseLoopCounter, false);
596 
597     // Disable compilations through training data replay.
598     FLAG_SET_DEFAULT(ReplayTraining, false);
599   }
600 
601   if (UseOnStackReplacement && !UseLoopCounter) {
602     warning("On-stack-replacement requires loop counters; enabling loop counters");
603     FLAG_SET_DEFAULT(UseLoopCounter, true);
604   }
605 
606   if (ProfileInterpreter && CompilerConfig::is_c1_simple_only()) {
607     if (!FLAG_IS_DEFAULT(ProfileInterpreter)) {
608         warning("ProfileInterpreter disabled due to client emulation mode");
609     }
610     FLAG_SET_CMDLINE(ProfileInterpreter, false);
611   }
612 
613 #ifdef COMPILER2
614   if (!EliminateLocks) {
615     EliminateNestedLocks = false;
616   }
617   if (!Inline || !IncrementalInline) {
618     IncrementalInline = false;
619     IncrementalInlineMH = false;
620     IncrementalInlineVirtual = false;
621     StressIncrementalInlining = false;
622   }
623 #ifndef PRODUCT
624   if (!IncrementalInline) {
625     AlwaysIncrementalInline = false;
626   }
627   if (FLAG_IS_CMDLINE(PrintIdealGraph) && !PrintIdealGraph) {
628     FLAG_SET_ERGO(PrintIdealGraphLevel, -1);
629   }
630 #endif
631   if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) {
632     // nothing to use the profiling, turn if off
633     FLAG_SET_DEFAULT(TypeProfileLevel, 0);
634   }
635   if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
636     FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
637   }
638   if (FLAG_IS_DEFAULT(LoopStripMiningIterShortLoop)) {
639     // blind guess
640     LoopStripMiningIterShortLoop = LoopStripMiningIter / 10;
641   }
642 #endif // COMPILER2
643 }