1 /*
2 * Copyright (c) 2016, 2020, 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 "code/codeCache.hpp"
27 #include "runtime/globals.hpp"
28 #include "runtime/globals_extension.hpp"
29 #include "compiler/compilerDefinitions.hpp"
30 #include "gc/shared/gcConfig.hpp"
31 #include "utilities/defaultStream.hpp"
32
33 const char* compilertype2name_tab[compiler_number_of_types] = {
34 "",
35 "c1",
36 "c2",
37 "jvmci"
38 };
39
40 #ifdef TIERED
41 bool CompilationModeFlag::_quick_only = false;
42 bool CompilationModeFlag::_high_only = false;
43 bool CompilationModeFlag::_high_only_quick_internal = false;
44
45
46 bool CompilationModeFlag::initialize() {
47 if (CompilationMode != NULL) {
48 if (strcmp(CompilationMode, "default") == 0) {
49 // Do nothing, just support the "default" keyword.
50 } else if (strcmp(CompilationMode, "quick-only") == 0) {
51 _quick_only = true;
52 } else if (strcmp(CompilationMode, "high-only") == 0) {
53 _high_only = true;
54 } else if (strcmp(CompilationMode, "high-only-quick-internal") == 0) {
55 _high_only_quick_internal = true;
56 } else {
57 jio_fprintf(defaultStream::error_stream(), "Unsupported compilation mode '%s', supported modes are: quick-only, high-only, high-only-quick-internal\n", CompilationMode);
58 return false;
59 }
60 }
61 return true;
62 }
63
64 #endif
65
66 #if defined(COMPILER2)
67 CompLevel CompLevel_highest_tier = CompLevel_full_optimization; // pure C2 and tiered or JVMCI and tiered
68 #elif defined(COMPILER1)
69 CompLevel CompLevel_highest_tier = CompLevel_simple; // pure C1 or JVMCI
70 #else
71 CompLevel CompLevel_highest_tier = CompLevel_none;
72 #endif
73
74 #if defined(COMPILER2)
75 CompMode Compilation_mode = CompMode_server;
76 #elif defined(COMPILER1)
77 CompMode Compilation_mode = CompMode_client;
78 #else
79 CompMode Compilation_mode = CompMode_none;
80 #endif
81
82 // Returns threshold scaled with CompileThresholdScaling
83 intx CompilerConfig::scaled_compile_threshold(intx threshold) {
84 return scaled_compile_threshold(threshold, CompileThresholdScaling);
85 }
86
87 // Returns freq_log scaled with CompileThresholdScaling
88 intx CompilerConfig::scaled_freq_log(intx freq_log) {
89 return scaled_freq_log(freq_log, CompileThresholdScaling);
90 }
91
92 // Returns threshold scaled with the value of scale.
93 // If scale < 0.0, threshold is returned without scaling.
94 intx CompilerConfig::scaled_compile_threshold(intx threshold, double scale) {
95 if (scale == 1.0 || scale < 0.0) {
96 return threshold;
97 } else {
98 return (intx)(threshold * scale);
99 }
100 }
101
102 // Returns freq_log scaled with the value of scale.
103 // Returned values are in the range of [0, InvocationCounter::number_of_count_bits + 1].
104 // If scale < 0.0, freq_log is returned without scaling.
105 intx CompilerConfig::scaled_freq_log(intx freq_log, double scale) {
106 // Check if scaling is necessary or if negative value was specified.
107 if (scale == 1.0 || scale < 0.0) {
108 return freq_log;
109 }
110 // Check values to avoid calculating log2 of 0.
111 if (scale == 0.0 || freq_log == 0) {
112 return 0;
113 }
114 // Determine the maximum notification frequency value currently supported.
115 // The largest mask value that the interpreter/C1 can handle is
116 // of length InvocationCounter::number_of_count_bits. Mask values are always
117 // one bit shorter then the value of the notification frequency. Set
118 // max_freq_bits accordingly.
119 intx max_freq_bits = InvocationCounter::number_of_count_bits + 1;
120 intx scaled_freq = scaled_compile_threshold((intx)1 << freq_log, scale);
121 if (scaled_freq == 0) {
122 // Return 0 right away to avoid calculating log2 of 0.
123 return 0;
124 } else if (scaled_freq > nth_bit(max_freq_bits)) {
125 return max_freq_bits;
126 } else {
127 return log2_intptr(scaled_freq);
128 }
129 }
130
131 #ifdef TIERED
132 void set_client_compilation_mode() {
133 Compilation_mode = CompMode_client;
134 CompLevel_highest_tier = CompLevel_simple;
135 FLAG_SET_ERGO(TieredCompilation, false);
136 FLAG_SET_ERGO(ProfileInterpreter, false);
137 #if INCLUDE_JVMCI
138 FLAG_SET_ERGO(EnableJVMCI, false);
139 FLAG_SET_ERGO(UseJVMCICompiler, false);
140 #endif
141 #if INCLUDE_AOT
142 FLAG_SET_ERGO(UseAOT, false);
143 #endif
144 if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) {
145 FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
146 }
147 if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
148 FLAG_SET_ERGO(InitialCodeCacheSize, 160*K);
149 }
150 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
151 FLAG_SET_ERGO(ReservedCodeCacheSize, 32*M);
152 }
153 if (FLAG_IS_DEFAULT(NonProfiledCodeHeapSize)) {
154 FLAG_SET_ERGO(NonProfiledCodeHeapSize, 27*M);
155 }
156 if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize)) {
157 FLAG_SET_ERGO(ProfiledCodeHeapSize, 0);
158 }
159 if (FLAG_IS_DEFAULT(NonNMethodCodeHeapSize)) {
160 FLAG_SET_ERGO(NonNMethodCodeHeapSize, 5*M);
161 }
162 if (FLAG_IS_DEFAULT(CodeCacheExpansionSize)) {
163 FLAG_SET_ERGO(CodeCacheExpansionSize, 32*K);
164 }
165 if (FLAG_IS_DEFAULT(MetaspaceSize)) {
166 FLAG_SET_ERGO(MetaspaceSize, MIN2(12*M, MaxMetaspaceSize));
167 }
168 if (FLAG_IS_DEFAULT(MaxRAM)) {
169 // Do not use FLAG_SET_ERGO to update MaxRAM, as this will impact
170 // heap setting done based on available phys_mem (see Arguments::set_heap_size).
171 FLAG_SET_DEFAULT(MaxRAM, 1ULL*G);
172 }
173 if (FLAG_IS_DEFAULT(CompileThreshold)) {
174 FLAG_SET_ERGO(CompileThreshold, 1500);
175 }
176 if (FLAG_IS_DEFAULT(OnStackReplacePercentage)) {
177 FLAG_SET_ERGO(OnStackReplacePercentage, 933);
178 }
179 if (FLAG_IS_DEFAULT(CICompilerCount)) {
180 FLAG_SET_ERGO(CICompilerCount, 1);
181 }
182 }
183
184 bool compilation_mode_selected() {
185 return !FLAG_IS_DEFAULT(TieredCompilation) ||
186 !FLAG_IS_DEFAULT(TieredStopAtLevel) ||
187 !FLAG_IS_DEFAULT(UseAOT)
188 JVMCI_ONLY(|| !FLAG_IS_DEFAULT(EnableJVMCI)
189 || !FLAG_IS_DEFAULT(UseJVMCICompiler));
190 }
191
192 void select_compilation_mode_ergonomically() {
193 #if defined(_WINDOWS) && !defined(_LP64)
194 if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) {
195 FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
196 }
197 #endif
198 if (NeverActAsServerClassMachine) {
199 set_client_compilation_mode();
200 }
201 }
202
203
204 void CompilerConfig::set_tiered_flags() {
205 // Increase the code cache size - tiered compiles a lot more.
206 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
207 FLAG_SET_ERGO(ReservedCodeCacheSize,
208 MIN2(CODE_CACHE_DEFAULT_LIMIT, (size_t)ReservedCodeCacheSize * 5));
209 }
210 // Enable SegmentedCodeCache if TieredCompilation is enabled, ReservedCodeCacheSize >= 240M
211 // and the code cache contains at least 8 pages (segmentation disables advantage of huge pages).
212 if (FLAG_IS_DEFAULT(SegmentedCodeCache) && ReservedCodeCacheSize >= 240*M &&
213 8 * CodeCache::page_size() <= ReservedCodeCacheSize) {
214 FLAG_SET_ERGO(SegmentedCodeCache, true);
215 }
216 if (!UseInterpreter) { // -Xcomp
217 Tier3InvokeNotifyFreqLog = 0;
218 Tier4InvocationThreshold = 0;
219 }
220
221 if (CompileThresholdScaling < 0) {
222 vm_exit_during_initialization("Negative value specified for CompileThresholdScaling", NULL);
223 }
224
225 if (CompilationModeFlag::disable_intermediate()) {
226 if (FLAG_IS_DEFAULT(Tier0ProfilingStartPercentage)) {
227 FLAG_SET_DEFAULT(Tier0ProfilingStartPercentage, 33);
228 }
229 }
230
231 // Scale tiered compilation thresholds.
232 // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves compilation thresholds unchanged.
233 if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) {
234 FLAG_SET_ERGO(Tier0InvokeNotifyFreqLog, scaled_freq_log(Tier0InvokeNotifyFreqLog));
235 FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, scaled_freq_log(Tier0BackedgeNotifyFreqLog));
236
237 FLAG_SET_ERGO(Tier3InvocationThreshold, scaled_compile_threshold(Tier3InvocationThreshold));
238 FLAG_SET_ERGO(Tier3MinInvocationThreshold, scaled_compile_threshold(Tier3MinInvocationThreshold));
239 FLAG_SET_ERGO(Tier3CompileThreshold, scaled_compile_threshold(Tier3CompileThreshold));
240 FLAG_SET_ERGO(Tier3BackEdgeThreshold, scaled_compile_threshold(Tier3BackEdgeThreshold));
241
242 // Tier2{Invocation,MinInvocation,Compile,Backedge}Threshold should be scaled here
243 // once these thresholds become supported.
244
245 FLAG_SET_ERGO(Tier2InvokeNotifyFreqLog, scaled_freq_log(Tier2InvokeNotifyFreqLog));
246 FLAG_SET_ERGO(Tier2BackedgeNotifyFreqLog, scaled_freq_log(Tier2BackedgeNotifyFreqLog));
247
248 FLAG_SET_ERGO(Tier3InvokeNotifyFreqLog, scaled_freq_log(Tier3InvokeNotifyFreqLog));
249 FLAG_SET_ERGO(Tier3BackedgeNotifyFreqLog, scaled_freq_log(Tier3BackedgeNotifyFreqLog));
250
251 FLAG_SET_ERGO(Tier23InlineeNotifyFreqLog, scaled_freq_log(Tier23InlineeNotifyFreqLog));
252
253 FLAG_SET_ERGO(Tier4InvocationThreshold, scaled_compile_threshold(Tier4InvocationThreshold));
254 FLAG_SET_ERGO(Tier4MinInvocationThreshold, scaled_compile_threshold(Tier4MinInvocationThreshold));
255 FLAG_SET_ERGO(Tier4CompileThreshold, scaled_compile_threshold(Tier4CompileThreshold));
256 FLAG_SET_ERGO(Tier4BackEdgeThreshold, scaled_compile_threshold(Tier4BackEdgeThreshold));
257
258 if (CompilationModeFlag::disable_intermediate()) {
259 FLAG_SET_ERGO(Tier40InvocationThreshold, scaled_compile_threshold(Tier40InvocationThreshold));
260 FLAG_SET_ERGO(Tier40MinInvocationThreshold, scaled_compile_threshold(Tier40MinInvocationThreshold));
261 FLAG_SET_ERGO(Tier40CompileThreshold, scaled_compile_threshold(Tier40CompileThreshold));
262 FLAG_SET_ERGO(Tier40BackEdgeThreshold, scaled_compile_threshold(Tier40BackEdgeThreshold));
263 }
264
265 #if INCLUDE_AOT
266 if (UseAOT) {
267 FLAG_SET_ERGO(Tier3AOTInvocationThreshold, scaled_compile_threshold(Tier3AOTInvocationThreshold));
268 FLAG_SET_ERGO(Tier3AOTMinInvocationThreshold, scaled_compile_threshold(Tier3AOTMinInvocationThreshold));
269 FLAG_SET_ERGO(Tier3AOTCompileThreshold, scaled_compile_threshold(Tier3AOTCompileThreshold));
270 FLAG_SET_ERGO(Tier3AOTBackEdgeThreshold, scaled_compile_threshold(Tier3AOTBackEdgeThreshold));
271
272 if (CompilationModeFlag::disable_intermediate()) {
273 FLAG_SET_ERGO(Tier0AOTInvocationThreshold, scaled_compile_threshold(Tier0AOTInvocationThreshold));
274 FLAG_SET_ERGO(Tier0AOTMinInvocationThreshold, scaled_compile_threshold(Tier0AOTMinInvocationThreshold));
275 FLAG_SET_ERGO(Tier0AOTCompileThreshold, scaled_compile_threshold(Tier0AOTCompileThreshold));
276 FLAG_SET_ERGO(Tier0AOTBackEdgeThreshold, scaled_compile_threshold(Tier0AOTBackEdgeThreshold));
277 }
278 }
279 #endif // INCLUDE_AOT
280 }
281
282 // Reduce stack usage due to inlining of methods which require much stack.
283 // (High tier compiler can inline better based on profiling information.)
284 if (FLAG_IS_DEFAULT(C1InlineStackLimit) &&
285 TieredStopAtLevel == CompLevel_full_optimization && !CompilationModeFlag::quick_only()) {
286 FLAG_SET_DEFAULT(C1InlineStackLimit, 5);
287 }
288 }
289
290 #endif // TIERED
291
292 #if INCLUDE_JVMCI
293 void set_jvmci_specific_flags() {
294 if (UseJVMCICompiler) {
295 Compilation_mode = CompMode_server;
296
297 if (FLAG_IS_DEFAULT(TypeProfileWidth)) {
298 FLAG_SET_DEFAULT(TypeProfileWidth, 8);
299 }
300 if (FLAG_IS_DEFAULT(TypeProfileLevel)) {
301 FLAG_SET_DEFAULT(TypeProfileLevel, 0);
302 }
303
304 if (UseJVMCINativeLibrary) {
305 // SVM compiled code requires more stack space
306 if (FLAG_IS_DEFAULT(CompilerThreadStackSize)) {
307 // Duplicate logic in the implementations of os::create_thread
308 // so that we can then double the computed stack size. Once
309 // the stack size requirements of SVM are better understood,
310 // this logic can be pushed down into os::create_thread.
311 int stack_size = CompilerThreadStackSize;
312 if (stack_size == 0) {
313 stack_size = VMThreadStackSize;
314 }
315 if (stack_size != 0) {
316 FLAG_SET_DEFAULT(CompilerThreadStackSize, stack_size * 2);
317 }
318 }
319 } else {
320 #ifdef TIERED
321 if (!TieredCompilation) {
322 warning("Disabling tiered compilation with non-native JVMCI compiler is not recommended. "
323 "Turning on tiered compilation and disabling intermediate compilation levels instead. ");
324 FLAG_SET_ERGO(TieredCompilation, true);
325 if (CompilationModeFlag::normal()) {
326 CompilationModeFlag::set_high_only_quick_internal(true);
327 }
328 if (CICompilerCount < 2 && CompilationModeFlag::quick_internal()) {
329 warning("Increasing number of compiler threads for JVMCI compiler.");
330 FLAG_SET_ERGO(CICompilerCount, 2);
331 }
332 }
333 #else // TIERED
334 // Adjust the on stack replacement percentage to avoid early
335 // OSR compilations while JVMCI itself is warming up
336 if (FLAG_IS_DEFAULT(OnStackReplacePercentage)) {
337 FLAG_SET_DEFAULT(OnStackReplacePercentage, 933);
338 }
339 #endif // !TIERED
340 // JVMCI needs values not less than defaults
341 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
342 FLAG_SET_DEFAULT(ReservedCodeCacheSize, MAX2(64*M, ReservedCodeCacheSize));
343 }
344 if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
345 FLAG_SET_DEFAULT(InitialCodeCacheSize, MAX2(16*M, InitialCodeCacheSize));
346 }
347 if (FLAG_IS_DEFAULT(MetaspaceSize)) {
348 FLAG_SET_DEFAULT(MetaspaceSize, MIN2(MAX2(12*M, MetaspaceSize), MaxMetaspaceSize));
349 }
350 if (FLAG_IS_DEFAULT(NewSizeThreadIncrease)) {
351 FLAG_SET_DEFAULT(NewSizeThreadIncrease, MAX2(4*K, NewSizeThreadIncrease));
352 }
353 } // !UseJVMCINativeLibrary
354 } // UseJVMCICompiler
355 }
356 #endif // INCLUDE_JVMCI
357
358 bool CompilerConfig::check_args_consistency(bool status) {
359 // Check lower bounds of the code cache
360 // Template Interpreter code is approximately 3X larger in debug builds.
361 uint min_code_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3);
362 if (ReservedCodeCacheSize < InitialCodeCacheSize) {
363 jio_fprintf(defaultStream::error_stream(),
364 "Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n",
365 ReservedCodeCacheSize/K, InitialCodeCacheSize/K);
366 status = false;
367 } else if (ReservedCodeCacheSize < min_code_cache_size) {
368 jio_fprintf(defaultStream::error_stream(),
369 "Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\n", ReservedCodeCacheSize/K,
370 min_code_cache_size/K);
371 status = false;
372 } else if (ReservedCodeCacheSize > CODE_CACHE_SIZE_LIMIT) {
373 // Code cache size larger than CODE_CACHE_SIZE_LIMIT is not supported.
374 jio_fprintf(defaultStream::error_stream(),
375 "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
376 CODE_CACHE_SIZE_LIMIT/M);
377 status = false;
378 } else if (NonNMethodCodeHeapSize < min_code_cache_size) {
379 jio_fprintf(defaultStream::error_stream(),
380 "Invalid NonNMethodCodeHeapSize=%dK. Must be at least %uK.\n", NonNMethodCodeHeapSize/K,
381 min_code_cache_size/K);
382 status = false;
383 }
384
385 #ifdef _LP64
386 if (!FLAG_IS_DEFAULT(CICompilerCount) && !FLAG_IS_DEFAULT(CICompilerCountPerCPU) && CICompilerCountPerCPU) {
387 warning("The VM option CICompilerCountPerCPU overrides CICompilerCount.");
388 }
389 #endif
390
391 if (BackgroundCompilation && ReplayCompiles) {
392 if (!FLAG_IS_DEFAULT(BackgroundCompilation)) {
393 warning("BackgroundCompilation disabled due to ReplayCompiles option.");
394 }
395 FLAG_SET_CMDLINE(BackgroundCompilation, false);
396 }
397
398 #ifdef COMPILER2
399 if (PostLoopMultiversioning && !RangeCheckElimination) {
400 if (!FLAG_IS_DEFAULT(PostLoopMultiversioning)) {
401 warning("PostLoopMultiversioning disabled because RangeCheckElimination is disabled.");
402 }
403 FLAG_SET_CMDLINE(PostLoopMultiversioning, false);
404 }
405 if (UseCountedLoopSafepoints && LoopStripMiningIter == 0) {
406 if (!FLAG_IS_DEFAULT(UseCountedLoopSafepoints) || !FLAG_IS_DEFAULT(LoopStripMiningIter)) {
407 warning("When counted loop safepoints are enabled, LoopStripMiningIter must be at least 1 (a safepoint every 1 iteration): setting it to 1");
408 }
409 LoopStripMiningIter = 1;
410 } else if (!UseCountedLoopSafepoints && LoopStripMiningIter > 0) {
411 if (!FLAG_IS_DEFAULT(UseCountedLoopSafepoints) || !FLAG_IS_DEFAULT(LoopStripMiningIter)) {
412 warning("Disabling counted safepoints implies no loop strip mining: setting LoopStripMiningIter to 0");
413 }
414 LoopStripMiningIter = 0;
415 }
416 #endif // COMPILER2
417
418 if (Arguments::is_interpreter_only()) {
419 if (UseCompiler) {
420 if (!FLAG_IS_DEFAULT(UseCompiler)) {
421 warning("UseCompiler disabled due to -Xint.");
422 }
423 FLAG_SET_CMDLINE(UseCompiler, false);
424 }
425 if (ProfileInterpreter) {
426 if (!FLAG_IS_DEFAULT(ProfileInterpreter)) {
427 warning("ProfileInterpreter disabled due to -Xint.");
428 }
429 FLAG_SET_CMDLINE(ProfileInterpreter, false);
430 }
431 if (TieredCompilation) {
432 if (!FLAG_IS_DEFAULT(TieredCompilation)) {
433 warning("TieredCompilation disabled due to -Xint.");
434 }
435 FLAG_SET_CMDLINE(TieredCompilation, false);
436 }
437 #if INCLUDE_JVMCI
438 if (EnableJVMCI) {
439 if (!FLAG_IS_DEFAULT(EnableJVMCI) || !FLAG_IS_DEFAULT(UseJVMCICompiler)) {
440 warning("JVMCI Compiler disabled due to -Xint.");
441 }
442 FLAG_SET_CMDLINE(EnableJVMCI, false);
443 FLAG_SET_CMDLINE(UseJVMCICompiler, false);
444 }
445 #endif
446 } else {
447 #if INCLUDE_JVMCI
448 status = status && JVMCIGlobals::check_jvmci_flags_are_consistent();
449 #endif
450 }
451 return status;
452 }
453
454 void CompilerConfig::ergo_initialize() {
455 if (Arguments::is_interpreter_only()) {
456 return; // Nothing to do.
457 }
458
459 #ifdef TIERED
460 if (!compilation_mode_selected()) {
461 select_compilation_mode_ergonomically();
462 }
463 #endif
464
465 #if INCLUDE_JVMCI
466 // Check that JVMCI compiler supports selested GC.
467 // Should be done after GCConfig::initialize() was called.
468 JVMCIGlobals::check_jvmci_supported_gc();
469
470 // Do JVMCI specific settings
471 set_jvmci_specific_flags();
472 #endif
473
474 #ifdef TIERED
475 if (TieredCompilation) {
476 set_tiered_flags();
477 } else
478 #endif
479 {
480 // Scale CompileThreshold
481 // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged.
482 if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) {
483 FLAG_SET_ERGO(CompileThreshold, scaled_compile_threshold(CompileThreshold));
484 }
485 }
486
487 if (FLAG_IS_DEFAULT(SweeperThreshold)) {
488 if ((SweeperThreshold * ReservedCodeCacheSize / 100) > (1.2 * M)) {
489 // Cap default SweeperThreshold value to an equivalent of 1.2 Mb
490 FLAG_SET_ERGO(SweeperThreshold, (1.2 * M * 100) / ReservedCodeCacheSize);
491 }
492 }
493
494 if (UseOnStackReplacement && !UseLoopCounter) {
495 warning("On-stack-replacement requires loop counters; enabling loop counters");
496 FLAG_SET_DEFAULT(UseLoopCounter, true);
497 }
498
499 #ifdef COMPILER2
500 if (!EliminateLocks) {
501 EliminateNestedLocks = false;
502 }
503 if (!Inline) {
504 IncrementalInline = false;
505 }
506 #ifndef PRODUCT
507 if (!IncrementalInline) {
508 AlwaysIncrementalInline = false;
509 }
510 if (FLAG_IS_CMDLINE(PrintIdealGraph) && !PrintIdealGraph) {
511 FLAG_SET_ERGO(PrintIdealGraphLevel, -1);
512 }
513 #endif
514 if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) {
515 // nothing to use the profiling, turn if off
516 FLAG_SET_DEFAULT(TypeProfileLevel, 0);
517 }
518 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
519 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
520 }
521 if (FLAG_IS_DEFAULT(LoopStripMiningIterShortLoop)) {
522 // blind guess
523 LoopStripMiningIterShortLoop = LoopStripMiningIter / 10;
524 }
525 if (UseStackAllocation) {
526 if (!(UseSerialGC || UseParallelGC || UseG1GC)) {
527 vm_exit_during_initialization("UseStackAllocation is not supported with selected GC", GCConfig::hs_err_name());
528 FLAG_SET_DEFAULT(UseStackAllocation, false);
529 FLAG_SET_ERGO(UseStackAllocationRuntime, false);
530 } else {
531 FLAG_SET_ERGO(UseStackAllocationRuntime, true);
532 }
533 }
534 #endif // COMPILER2
535 }
536
537 static CompLevel highest_compile_level() {
538 return TieredCompilation ? MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier) : CompLevel_highest_tier;
539 }
540
541 bool is_c1_or_interpreter_only() {
542 if (Arguments::is_interpreter_only()) {
543 return true;
544 }
545
546 #if INCLUDE_AOT
547 if (UseAOT) {
548 return false;
549 }
550 #endif
551
552 if (highest_compile_level() < CompLevel_full_optimization) {
553 #if INCLUDE_JVMCI
554 if (TieredCompilation) {
555 return true;
556 }
557 // This happens on jvm variant with C2 disabled and JVMCI
558 // enabled.
559 return !UseJVMCICompiler;
560 #else
561 return true;
562 #endif
563 }
564
565 #ifdef TIERED
566 // The quick-only compilation mode is c1 only. However,
567 // CompilationModeFlag only takes effect with TieredCompilation
568 // enabled.
569 if (TieredCompilation && CompilationModeFlag::quick_only()) {
570 return true;
571 }
572 #endif
573 return false;
574 }