src/hotspot/share/compiler/compilerDefinitions.cpp - master - githubmirror/panama-vector

src/hotspot/share/compiler/compilerDefinitions.cpp
513 строк21 KB
Chad Rakoczy
8388358: HotCodeHeap should throw warning when enabled without C2
17 июл 2026, 18:51
17 июл 2026, 18:51ae6332d
/*
 * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#include "code/codeCache.hpp"
#include "compiler/compilerDefinitions.inline.hpp"
#include "interpreter/invocationCounter.hpp"
#include "jvm_io.h"
#include "runtime/arguments.hpp"
#include "runtime/continuation.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/flags/jvmFlagAccess.hpp"
#include "runtime/flags/jvmFlagConstraintsCompiler.hpp"
#include "runtime/flags/jvmFlagLimit.hpp"
#include "runtime/globals.hpp"
#include "runtime/globals_extension.hpp"
#include "utilities/defaultStream.hpp"

const char* compilertype2name_tab[compiler_number_of_types] = {
  "",
  "c1",
  "c2"
};

CompilationModeFlag::Mode CompilationModeFlag::_mode = CompilationModeFlag::Mode::NORMAL;

static void print_mode_unavailable(const char* mode_name, const char* reason) {
  warning("%s compilation mode unavailable because %s.", mode_name, reason);
}

bool CompilationModeFlag::initialize() {
  _mode = Mode::NORMAL;
  // During parsing we want to be very careful not to use any methods of CompilerConfig that depend on
  // CompilationModeFlag.
  if (CompilationMode != nullptr) {
    if (strcmp(CompilationMode, "default") == 0 || strcmp(CompilationMode, "normal") == 0) {
      assert(_mode == Mode::NORMAL, "Precondition");
    } else if (strcmp(CompilationMode, "quick-only") == 0) {
      if (!CompilerConfig::has_c1()) {
        print_mode_unavailable("quick-only", "there is no c1 present");
      } else {
        _mode = Mode::QUICK_ONLY;
      }
    } else if (strcmp(CompilationMode, "high-only") == 0) {
      if (!CompilerConfig::has_c2()) {
        print_mode_unavailable("high-only", "there is no c2 compiler present");
      } else {
        _mode = Mode::HIGH_ONLY;
      }
    } else {
      print_error();
      return false;
    }
  }

  // Now that the flag is parsed, we can use any methods of CompilerConfig.
  if (normal()) {
    if (CompilerConfig::is_c1_simple_only()) {
      _mode = Mode::QUICK_ONLY;
    } else if (CompilerConfig::is_c2_only()) {
      _mode = Mode::HIGH_ONLY;
    }
  }
  return true;
}

void CompilationModeFlag::print_error() {
  jio_fprintf(defaultStream::error_stream(), "Unsupported compilation mode '%s', available modes are:", CompilationMode);
  bool comma = false;
  if (CompilerConfig::has_c1()) {
    jio_fprintf(defaultStream::error_stream(), "%s quick-only", comma ? "," : "");
    comma = true;
  }
  if (CompilerConfig::has_c2()) {
    jio_fprintf(defaultStream::error_stream(), "%s high-only", comma ? "," : "");
    comma = true;
  }
  jio_fprintf(defaultStream::error_stream(), "\n");
}

// Returns threshold scaled with CompileThresholdScaling
intx CompilerConfig::scaled_compile_threshold(intx threshold) {
  return scaled_compile_threshold(threshold, CompileThresholdScaling);
}

// Returns freq_log scaled with CompileThresholdScaling
intx CompilerConfig::scaled_freq_log(intx freq_log) {
  return scaled_freq_log(freq_log, CompileThresholdScaling);
}

// For XXXThreshold flags, which all have a valid range of [0 .. max_jint]
intx CompilerConfig::jvmflag_scaled_compile_threshold(intx threshold) {
  return MAX2((intx)0, MIN2(scaled_compile_threshold(threshold), (intx)max_jint));
}

// For XXXNotifyFreqLog flags, which all have a valid range of [0 .. 30]
intx CompilerConfig::jvmflag_scaled_freq_log(intx freq_log) {
  return MAX2((intx)0, MIN2(scaled_freq_log(freq_log), (intx)30));
}

// Returns threshold scaled with the value of scale.
// If scale < 0.0, threshold is returned without scaling.
intx CompilerConfig::scaled_compile_threshold(intx threshold, double scale) {
  assert(threshold >= 0, "must be");
  if (scale == 1.0 || scale < 0.0) {
    return threshold;
  } else {
    double v = threshold * scale;
    assert(v >= 0, "must be");
    if (g_isnan(v) || !g_isfinite(v)) {
      return max_intx;
    }
    int exp;
    (void) frexp(v, &exp);
    int max_exp = sizeof(intx) * BitsPerByte - 1;
    if (exp > max_exp) {
      return max_intx;
    }
    intx r = (intx)(v);
    assert(r >= 0, "must be");
    return r;
  }
}

// Returns freq_log scaled with the value of scale.
// Returned values are in the range of [0, InvocationCounter::number_of_count_bits + 1].
// If scale < 0.0, freq_log is returned without scaling.
intx CompilerConfig::scaled_freq_log(intx freq_log, double scale) {
  // Check if scaling is necessary or if negative value was specified.
  if (scale == 1.0 || scale < 0.0) {
    return freq_log;
  }
  // Check values to avoid calculating log2 of 0.
  if (scale == 0.0 || freq_log == 0) {
    return 0;
  }
  // Determine the maximum notification frequency value currently supported.
  // The largest mask value that the interpreter/C1 can handle is
  // of length InvocationCounter::number_of_count_bits. Mask values are always
  // one bit shorter then the value of the notification frequency. Set
  // max_freq_bits accordingly.
  int max_freq_bits = InvocationCounter::number_of_count_bits + 1;
  intx scaled_freq = scaled_compile_threshold((intx)1 << freq_log, scale);

  if (scaled_freq == 0) {
    // Return 0 right away to avoid calculating log2 of 0.
    return 0;
  } else {
    return MIN2(log2i(scaled_freq), max_freq_bits);
  }
}

static bool check_legacy_flags() {
  JVMFlag* compile_threshold_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(CompileThreshold));
  if (JVMFlagAccess::check_constraint(compile_threshold_flag, JVMFlagLimit::get_constraint(compile_threshold_flag)->constraint_func(), false) != JVMFlag::SUCCESS) {
    return false;
  }
  JVMFlag* on_stack_replace_percentage_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(OnStackReplacePercentage));
  if (JVMFlagAccess::check_constraint(on_stack_replace_percentage_flag, JVMFlagLimit::get_constraint(on_stack_replace_percentage_flag)->constraint_func(), false) != JVMFlag::SUCCESS) {
    return false;
  }
  JVMFlag* interpreter_profile_percentage_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(InterpreterProfilePercentage));
  if (JVMFlagAccess::check_range(interpreter_profile_percentage_flag, false) != JVMFlag::SUCCESS) {
    return false;
  }
  return true;
}

void CompilerConfig::set_legacy_emulation_flags() {
  // Any legacy flags set?
  if (!FLAG_IS_DEFAULT(CompileThreshold)         ||
      !FLAG_IS_DEFAULT(OnStackReplacePercentage) ||
      !FLAG_IS_DEFAULT(InterpreterProfilePercentage)) {
    if (CompilerConfig::is_c1_only() || CompilerConfig::is_c2_only()) {
      // This function is called before these flags are validated. In order to not confuse the user with extraneous
      // error messages, we check the validity of these flags here and bail out if any of them are invalid.
      if (!check_legacy_flags()) {
        return;
      }
      // Note, we do not scale CompileThreshold before this because the tiered flags are
      // all going to be scaled further in set_compilation_policy_flags().
      const intx threshold = CompileThreshold;
      const intx profile_threshold = threshold * InterpreterProfilePercentage / 100;
      const intx osr_threshold = threshold * OnStackReplacePercentage / 100;
      const intx osr_profile_threshold = osr_threshold * InterpreterProfilePercentage / 100;

      const intx threshold_log = log2i_graceful(CompilerConfig::is_c1_only() ? threshold : profile_threshold);
      const intx osr_threshold_log = log2i_graceful(CompilerConfig::is_c1_only() ? osr_threshold : osr_profile_threshold);

      if (Tier0InvokeNotifyFreqLog > threshold_log) {
        FLAG_SET_ERGO(Tier0InvokeNotifyFreqLog, MAX2<intx>(0, threshold_log));
      }

      // Note: Emulation oddity. The legacy policy limited the amount of callbacks from the
      // interpreter for backedge events to once every 1024 counter increments.
      // We simulate this behavior by limiting the backedge notification frequency to be
      // at least 2^10.
      if (Tier0BackedgeNotifyFreqLog > osr_threshold_log) {
        FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, MAX2<intx>(10, osr_threshold_log));
      }
      // Adjust the tiered policy flags to approximate the legacy behavior.
      FLAG_SET_ERGO(Tier3InvocationThreshold, threshold);
      FLAG_SET_ERGO(Tier3MinInvocationThreshold, threshold);
      FLAG_SET_ERGO(Tier3CompileThreshold, threshold);
      FLAG_SET_ERGO(Tier3BackEdgeThreshold, osr_threshold);
      if (CompilerConfig::is_c2_only()) {
        FLAG_SET_ERGO(Tier4InvocationThreshold, threshold);
        FLAG_SET_ERGO(Tier4MinInvocationThreshold, threshold);
        FLAG_SET_ERGO(Tier4CompileThreshold, threshold);
        FLAG_SET_ERGO(Tier4BackEdgeThreshold, osr_threshold);
        FLAG_SET_ERGO(Tier0ProfilingStartPercentage, InterpreterProfilePercentage);
      }
    } else {
      // Normal tiered mode, ignore legacy flags
    }
  }
  // Scale CompileThreshold
  // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged.
  if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0 && CompileThreshold > 0) {
    intx scaled_value = scaled_compile_threshold(CompileThreshold);
    if (CompileThresholdConstraintFunc(scaled_value, true) != JVMFlag::VIOLATES_CONSTRAINT) {
      FLAG_SET_ERGO(CompileThreshold, scaled_value);
    }
  }
}


void CompilerConfig::set_compilation_policy_flags() {
  if (is_tiered()) {
    // Increase the code cache size - tiered compiles a lot more.
    if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
      FLAG_SET_ERGO(ReservedCodeCacheSize,
                    MIN2(CODE_CACHE_DEFAULT_LIMIT, ReservedCodeCacheSize * 5));
    }
    // Enable SegmentedCodeCache if tiered compilation is enabled, ReservedCodeCacheSize >= 240M
    // and the code cache contains at least 8 pages (segmentation disables advantage of huge pages).
    if (FLAG_IS_DEFAULT(SegmentedCodeCache) && ReservedCodeCacheSize >= 240*M &&
        8 * CodeCache::page_size() <= ReservedCodeCacheSize) {
      FLAG_SET_ERGO(SegmentedCodeCache, true);
    }
    if (Arguments::is_compiler_only()) { // -Xcomp
      // Be much more aggressive in tiered mode with -Xcomp and exercise C2 more.
      // We will first compile a level 3 version (C1 with full profiling), then do one invocation of it and
      // compile a level 4 (C2) and then continue executing it.
      if (FLAG_IS_DEFAULT(Tier3InvokeNotifyFreqLog)) {
        FLAG_SET_CMDLINE(Tier3InvokeNotifyFreqLog, 0);
      }
      if (FLAG_IS_DEFAULT(Tier4InvocationThreshold)) {
        FLAG_SET_CMDLINE(Tier4InvocationThreshold, 0);
      }
    }
  }

#ifdef COMPILER2
  if (HotCodeHeap && !is_c2_enabled()) {
    warning("HotCodeHeap disabled because C2 is disabled.");
    FLAG_SET_ERGO(HotCodeHeap, false);
    FLAG_SET_ERGO(HotCodeHeapSize, 0);
  } else if (HotCodeHeap) {
    if (FLAG_IS_DEFAULT(SegmentedCodeCache)) {
      FLAG_SET_ERGO(SegmentedCodeCache, true);
    } else if (!SegmentedCodeCache) {
      vm_exit_during_initialization("HotCodeHeap requires SegmentedCodeCache enabled");
    }

    if (FLAG_IS_DEFAULT(NMethodRelocation)) {
      FLAG_SET_ERGO(NMethodRelocation, true);
    } else if (!NMethodRelocation) {
      vm_exit_during_initialization("HotCodeHeap requires NMethodRelocation enabled");
    }

    if (HotCodeMinSamplingMs > HotCodeMaxSamplingMs) {
      vm_exit_during_initialization("HotCodeMinSamplingMs cannot be larger than HotCodeMaxSamplingMs");
    }
  } else if (HotCodeHeapSize > 0) {
    vm_exit_during_initialization("HotCodeHeapSize requires HotCodeHeap enabled");
  }
#else
  if (HotCodeHeapSize > 0) {
    vm_exit_during_initialization("HotCodeHeapSize requires C2 present");
  }
#endif // COMPILER2

  if (CompileThresholdScaling < 0) {
    vm_exit_during_initialization("Negative value specified for CompileThresholdScaling");
  }

  if (CompilationModeFlag::disable_intermediate()) {
    if (FLAG_IS_DEFAULT(Tier0ProfilingStartPercentage)) {
      FLAG_SET_DEFAULT(Tier0ProfilingStartPercentage, 33);
    }

    if (FLAG_IS_DEFAULT(Tier4InvocationThreshold)) {
      FLAG_SET_DEFAULT(Tier4InvocationThreshold, 5000);
    }
    if (FLAG_IS_DEFAULT(Tier4MinInvocationThreshold)) {
      FLAG_SET_DEFAULT(Tier4MinInvocationThreshold, 600);
    }
    if (FLAG_IS_DEFAULT(Tier4CompileThreshold)) {
      FLAG_SET_DEFAULT(Tier4CompileThreshold, 10000);
    }
    if (FLAG_IS_DEFAULT(Tier4BackEdgeThreshold)) {
      FLAG_SET_DEFAULT(Tier4BackEdgeThreshold, 15000);
    }

    if (FLAG_IS_DEFAULT(Tier3InvocationThreshold)) {
      FLAG_SET_DEFAULT(Tier3InvocationThreshold, Tier4InvocationThreshold);
    }
    if (FLAG_IS_DEFAULT(Tier3MinInvocationThreshold)) {
      FLAG_SET_DEFAULT(Tier3MinInvocationThreshold, Tier4MinInvocationThreshold);
    }
    if (FLAG_IS_DEFAULT(Tier3CompileThreshold)) {
      FLAG_SET_DEFAULT(Tier3CompileThreshold, Tier4CompileThreshold);
    }
    if (FLAG_IS_DEFAULT(Tier3BackEdgeThreshold)) {
      FLAG_SET_DEFAULT(Tier3BackEdgeThreshold, Tier4BackEdgeThreshold);
    }

  }

  // Scale tiered compilation thresholds.
  // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves compilation thresholds unchanged.
  if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) {
    FLAG_SET_ERGO(Tier0InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier0InvokeNotifyFreqLog));
    FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier0BackedgeNotifyFreqLog));

    FLAG_SET_ERGO(Tier3InvocationThreshold, jvmflag_scaled_compile_threshold(Tier3InvocationThreshold));
    FLAG_SET_ERGO(Tier3MinInvocationThreshold, jvmflag_scaled_compile_threshold(Tier3MinInvocationThreshold));
    FLAG_SET_ERGO(Tier3CompileThreshold, jvmflag_scaled_compile_threshold(Tier3CompileThreshold));
    FLAG_SET_ERGO(Tier3BackEdgeThreshold, jvmflag_scaled_compile_threshold(Tier3BackEdgeThreshold));

    // Tier2{Invocation,MinInvocation,Compile,Backedge}Threshold should be scaled here
    // once these thresholds become supported.

    FLAG_SET_ERGO(Tier2InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier2InvokeNotifyFreqLog));
    FLAG_SET_ERGO(Tier2BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier2BackedgeNotifyFreqLog));

    FLAG_SET_ERGO(Tier3InvokeNotifyFreqLog, jvmflag_scaled_freq_log(Tier3InvokeNotifyFreqLog));
    FLAG_SET_ERGO(Tier3BackedgeNotifyFreqLog, jvmflag_scaled_freq_log(Tier3BackedgeNotifyFreqLog));

    FLAG_SET_ERGO(Tier23InlineeNotifyFreqLog, jvmflag_scaled_freq_log(Tier23InlineeNotifyFreqLog));

    FLAG_SET_ERGO(Tier4InvocationThreshold, jvmflag_scaled_compile_threshold(Tier4InvocationThreshold));
    FLAG_SET_ERGO(Tier4MinInvocationThreshold, jvmflag_scaled_compile_threshold(Tier4MinInvocationThreshold));
    FLAG_SET_ERGO(Tier4CompileThreshold, jvmflag_scaled_compile_threshold(Tier4CompileThreshold));
    FLAG_SET_ERGO(Tier4BackEdgeThreshold, jvmflag_scaled_compile_threshold(Tier4BackEdgeThreshold));
  }

#ifdef COMPILER1
  // Reduce stack usage due to inlining of methods which require much stack.
  // (High tier compiler can inline better based on profiling information.)
  if (FLAG_IS_DEFAULT(C1InlineStackLimit) &&
      TieredStopAtLevel == CompLevel_full_optimization && !CompilerConfig::is_c1_only()) {
    FLAG_SET_DEFAULT(C1InlineStackLimit, 5);
  }
#endif

  if (CompilerConfig::is_tiered() && CompilerConfig::is_c2_enabled()) {
#if defined(COMPILER2) && defined(_LP64)
    // LP64 specific inlining tuning for C2
    if (FLAG_IS_DEFAULT(InlineSmallCode)) {
      FLAG_SET_DEFAULT(InlineSmallCode, 2500);
    }
#endif
  }

}

bool CompilerConfig::check_args_consistency(bool status) {
  // Check lower bounds of the code cache
  // Template Interpreter code is approximately 3X larger in debug builds.
  size_t min_code_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3);
  if (ReservedCodeCacheSize < InitialCodeCacheSize) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid ReservedCodeCacheSize: %zuK. Must be at least InitialCodeCacheSize=%zuK.\n",
                ReservedCodeCacheSize/K, InitialCodeCacheSize/K);
    status = false;
  } else if (ReservedCodeCacheSize < min_code_cache_size) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid ReservedCodeCacheSize=%zuK. Must be at least %zuK.\n", ReservedCodeCacheSize/K,
                min_code_cache_size/K);
    status = false;
  } else if (ReservedCodeCacheSize > CODE_CACHE_SIZE_LIMIT) {
    // Code cache size larger than CODE_CACHE_SIZE_LIMIT is not supported.
    jio_fprintf(defaultStream::error_stream(),
                "Invalid ReservedCodeCacheSize=%zuM. Must be at most %zuM.\n", ReservedCodeCacheSize/M,
                CODE_CACHE_SIZE_LIMIT/M);
    status = false;
  } else if (NonNMethodCodeHeapSize < min_code_cache_size) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid NonNMethodCodeHeapSize=%zuK. Must be at least %zuK.\n", NonNMethodCodeHeapSize/K,
                min_code_cache_size/K);
    status = false;
  }

#ifdef _LP64
  if (!FLAG_IS_DEFAULT(CICompilerCount) && !FLAG_IS_DEFAULT(CICompilerCountPerCPU) && CICompilerCountPerCPU) {
    warning("The VM option CICompilerCountPerCPU overrides CICompilerCount.");
  }
#endif

  if (BackgroundCompilation && ReplayCompiles) {
    if (!FLAG_IS_DEFAULT(BackgroundCompilation)) {
      warning("BackgroundCompilation disabled due to ReplayCompiles option.");
    }
    FLAG_SET_CMDLINE(BackgroundCompilation, false);
  }

  if (CompilerConfig::is_interpreter_only()) {
    if (UseCompiler) {
      if (!FLAG_IS_DEFAULT(UseCompiler)) {
        warning("UseCompiler disabled due to -Xint.");
      }
      FLAG_SET_CMDLINE(UseCompiler, false);
    }
    if (ProfileInterpreter) {
      if (!FLAG_IS_DEFAULT(ProfileInterpreter)) {
        warning("ProfileInterpreter disabled due to -Xint.");
      }
      FLAG_SET_CMDLINE(ProfileInterpreter, false);
    }
    if (TieredCompilation) {
      if (!FLAG_IS_DEFAULT(TieredCompilation)) {
        warning("TieredCompilation disabled due to -Xint.");
      }
      FLAG_SET_CMDLINE(TieredCompilation, false);
    }
    if (SegmentedCodeCache) {
      warning("SegmentedCodeCache has no meaningful effect with -Xint");
      FLAG_SET_DEFAULT(SegmentedCodeCache, false);
    }
  }

  return status;
}

void CompilerConfig::ergo_initialize() {
#if !COMPILER1_OR_COMPILER2
  return;
#endif

  set_legacy_emulation_flags();
  set_compilation_policy_flags();

  if (UseOnStackReplacement && !UseLoopCounter) {
    warning("On-stack-replacement requires loop counters; enabling loop counters");
    FLAG_SET_DEFAULT(UseLoopCounter, true);
  }

  if (ProfileInterpreter && CompilerConfig::is_c1_simple_only()) {
    FLAG_SET_CMDLINE(ProfileInterpreter, false);
  }

#ifdef COMPILER2
  // Xcomp has no reasonable profiling information, enable inlining cold methods
  if (Arguments::is_compiler_only() && FLAG_IS_DEFAULT(InlineColdMethods)) {
    FLAG_SET_DEFAULT(InlineColdMethods, true);
  }
  if (!EliminateLocks) {
    EliminateNestedLocks = false;
  }
  if (!Inline || !IncrementalInline) {
    IncrementalInline = false;
    IncrementalInlineMH = false;
    IncrementalInlineVirtual = false;
    StressIncrementalInlining = false;
  }
#ifndef PRODUCT
  if (!IncrementalInline) {
    AlwaysIncrementalInline = false;
  }
  if (FLAG_IS_CMDLINE(PrintIdealGraph) && !PrintIdealGraph) {
    FLAG_SET_ERGO(PrintIdealGraphLevel, -1);
  }
#endif
  if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) {
    // nothing to use the profiling, turn if off
    FLAG_SET_DEFAULT(TypeProfileLevel, 0);
  }
  if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
    FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
  }
  if (FLAG_IS_DEFAULT(LoopStripMiningIterShortLoop)) {
    // blind guess
    LoopStripMiningIterShortLoop = LoopStripMiningIter / 10;
  }
  if (UseAutoVectorizationSpeculativeAliasingChecks && !LoopMultiversioning && !UseAutoVectorizationPredicate) {
    warning("Disabling UseAutoVectorizationSpeculativeAliasingChecks, because neither of the following is enabled:"
            "  LoopMultiversioning UseAutoVectorizationPredicate");
    UseAutoVectorizationSpeculativeAliasingChecks = false;
  }
#endif // COMPILER2
}