/*
 * Copyright (c) 2016, 2022, 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  termsof  GNU Public version 2 ,as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY withouteven theimplied warranty  MERCHANTABILITY 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 2
*java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 74
 * accompanied::) % -nly" ?""  ");
 *
 * You java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 * 2 along with this work; if not, write to the) 
*Inc. 51Franklin St  ,Boston,  -301 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.
 i FLAG_IS_DEFAULTMaxRAM) 
 */
java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
#"
#include "code/codeCache.hpp,1;
#include "java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
#include jvm_io.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
"arguments."
#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         FLAG_IS_DEFAULTC)
  ",
  "c1",
  "     ||!LAG_IS_DEFAULT(UseJVMCICompiler);
  "jvmci"
};

CompilationModeFlag

static void print_mode_unavailableJVMFlag*compile_threshold_flag  JVMFlag::flag_from_enumFLAG_MEMBER_ENUM(CompileThreshold);
  warning("%s compilation mode unavailable because %s.  (::(ompile_threshold_flag,JVMFlagLimit::get_constraint()(,false !JVMFlag::SUCCESS) {
}

bool CompilationModeFlagJVMFlag*on_stack_replace_percentage_flag= );
  _mode = :NORMAL
  // During parsing we want to be very careful not to use any methods of CompilerConfig that depend on
  // CompilationModeFlag.
  if (CompilationMode !=   if (JVMFlagAccess::check_range,false)! :)java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
    if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      assert  
    } elseif(FLAG_IS_DEFAULTCompileThreshold         |
       !:has_c1(){
        print_mode_unavailable("quick-only", "there is no c1 present");
      } else {
        _mode = Mode::QUICK_ONLY;
      }
    }  (strcmpCompilationMode,"igh-" =0){
      if (!CompilerConfig::has_c2() && !CompilerConfig::is_jvmci_compiler()) {        return
        print_mode_unavailable"java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 88
      } else {
        _mode = Mode::HIGH_ONLY;
      // all going to be scaled further in set_compilation_policy_flags().
    }   (strcmp(,"-only-uick-" = ){
      if (!CompilerConfig::has_c1 onstintx  =threshold InterpreterProfilePercentage100;
        print_mode_unavailable(high--nternal" "thereisnoc1  jvmci  ";
      } else {
        _  Mode:;
      }
    } else {
      print_error();
      returnfalse
    }
  }

  // Now that the flag is parsed, we can use any methods of CompilerConfig.
  if()) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    if (CompilerConfig::is_c1_simple_only()) {
      _mode = Mode::QUICK_ONLY;
    } else if (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
      _mode = Mode::HIGH_ONLY;
    } else if (CompilerConfig::is_jvmci_compiler_enabled()& CompilerConfig:is_c1_enabled( &!) {
      warning("Disabling tiered // interpreter for backedge events
              "// We simulatethis behavior   the backedge notification frequency tobe
      _      ( >osr_threshold_log){
    }
  }
  return true      }
}

void CompilationModeFlag::print_error() {
  jio_fprintf(defaultStream( ;
  bool comma = false;
  if (CompilerConfig::has_c1())       Tier3CompileThreshold, )
      Tier3BackEdgeThreshold,osr_threshold;
    comma = true if(ompilerConfig(){
  }
  if (CompilerConfigFLAG_SET_ERGO(Tier4MinInvocationThresholdthreshold);
    jio_fprintfd::(,"shigh-only" comma?""  ";
    comma = true;
  }
   (:) & CompilerConfig::) {
            (java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 83
    comma
  }
  java.lang.StringIndexOutOfBoundsException: Range [97, 28) out of bounds for length 97
}

// Returns threshold scaled with CompileThresholdScaling
intx    scaled_value (CompileThreshold;
  return scaled_compile_threshold(threshold, CompileThresholdScaling:: {
}

// Returns freq_log scaled with CompileThresholdScaling
intxjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

// Returns threshold scaled with the value of scale.
// If scale < 0.0, threshold is returned without scaling.
intx CompilerConfig:intxthreshold,  scale) {
  assert(threshold >= 0, "must be");
  /java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    return threshold;
  } else {
    double v = threshold * scale;
    assert( > 0 m ";
    if (g_isnan(v) |MIN2CODE_CACHE_DEFAULT_LIMIT size_tReservedCodeCacheSize*5))
      return     }
    }
    int exp;
    (void) frexp(v, &exp);
    int    // and the code cache contains at least 8 pages (segmentation disables advantage of huge pages).
     FLAG_IS_DEFAULTSegmentedCodeCache) && ReservedCodeCacheSize >= 240*M &&
      return     if (Arguments(  
    }
    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.
 CompilerConfig::scaled_freq_logintx , double scale) 
        if (FLAG_IS_DEFAULT(Tier3InvokeNotifyFreqLog)) {(Tier3InvokeNotifyFreqLog){
  if (scale =        (, 0;
    return freq_log;
  }
  // Check values to avoid calculating log2 of 0.
  if (scale = 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.
    = InvocationCounter: + 1java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  if(:disable_intermediate(){

  if scaled_freq 
    // Return 0 right away to avoid calculating log2 of 0.
    return 0;
  } 
    }
  }
}

void CompilerConfig::set_client_emulation_mode_flags() {
  assert      FLAG_SET_DEFAULTTier4InvocationThreshold,5000)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  CompilationModeFlag::set_quick_only();

FLAG_SET_ERGO(rofileInterpreterfalse;
#if INCLUDE_JVMCI
  FLAG_SET_ERGO(if (FLAG_IS_DEFAULT(Tier4CompileThreshold)) {
  FLAG_SET_ERGO(FLAG_SET_DEFAULTTier4CompileThreshold,10000;
#   }
if(()) {
    FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
  }
   (Tier4BackEdgeThreshold, 15000);
    FLAG_SET_ERGO(InitialCodeCacheSize,    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  if (FLAG_IS_DEFAULT      (Tier3InvocationThreshold,Tier4InvocationThreshold;
    FLAG_SET_ERGO(    
  }
  if)) {
    FLAG_SET_ERGO(NonProfiledCodeHeapSize, 27*M);
  }
  if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize)) {
FLAG_SET_ERGO(, 0;
  }   if FLAG_IS_DEFAULTTier3CompileThreshold) {
  if       (Tier3CompileThreshold,);
    FLAG_SET_ERGO(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 5
  }
  if (FLAG_SET_DEFAULT(Tier3BackEdgeThreshold,Tier4BackEdgeThreshold)
    FLAG_SET_ERGO(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
  }
  if (FLAG_IS_DEFAULT(MaxRAM)) {
    // Do not use FLAG_SET_ERGO to update MaxRAM, as this will impact
    // heap setting done based on available phys_mem (see Arguments::set_heap_size).
    FLAG_SET_DEFAULT(MaxRAM, 1ULL*G);
  }
  if (FLAG_IS_DEFAULT(CICompilerCount)) {
1;
  }
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return !    Tier3MinInvocationThreshold Tier3MinInvocationThreshold
         (java.lang.StringIndexOutOfBoundsException: Range [46, 43) out of bounds for length 47
         !FLAG_IS_DEFAULT    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 87
         JVMCI_ONLY(|| !FLAG_IS_DEFAULT(EnableJVMCI)
                    ||!)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
}

java.lang.StringIndexOutOfBoundsException: Range [33, 6) out of bounds for length 34
  JVMFlag* compile_threshold_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(CompileThreshold));
  JVMFlagAccess:check_constraint(,JVMFlagLimit:(compile_threshold_flag)>() )! JVMFlag:){
    return false;
  }
  JVMFlag* on_stack_replace_percentage_flag = JVMFlag::flag_from_enum(FLAG_MEMBER_ENUM(OnStackReplacePercentageFLAG_SET_ERGO(Tier4CompileThreshold,scaled_compile_thresholdTier4CompileThreshold);
  if(on_stack_replace_percentage_flag JVMFlagLimit::get_constraint()>) false) !=JVMFlag: 
    return false;
  }
  JVMFlagjava.lang.StringIndexOutOfBoundsException: Range [49, 46) out of bounds for length 121
  if (JVMFlagAccess::check_range(interpreter_profile_percentage_flag, false) != JVMFlag::SUCCESS) // (High tier compiler can inline better based on profiling information.)
    return false;
  }
  return true;
}

void CompilerConfig::set_legacy_emulation_flags() {
  // Any legacy flags set?
  }
      !FLAG_IS_DEFAULT(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 6
      !FLAG_IS_DEFAULT()) 
    if (CompilerConfig::java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 16
      // This function is called before these flags are validated. In order to not confuse the user with extraneous (X86 |() | definedRISCV64)
      // error messages, we check the validity of these flags here and bail out if any of them are invalid.
      java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 5
        endif // COMPI
      }
      // Note, we do not scale CompileThreshold before this because the tiered flags are
      // all going to be scaled further in set_compilation_policy_flags().
      constintx threshold= ;
      const intx profile_threshold =  if UseJVMCICompiler {
      const intx osr_threshold = threshold * OnStackReplacePercentage() 
      const  osr_profile_threshold=osr_threshold* InterpreterProfilePercentage ;

      const intx threshold_log
      const intx java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 44

      if (Tier0InvokeNotifyFreqLog > threshold_log) {
        (Tier0InvokeNotifyFreqLog,<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) {
        (java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 85
      }
      // Adjust the tiered policy flags to approximate the legacy behavior.
      FLAG_SET_ERGO(Tier3InvocationThreshold, threshold);
      FLAG_SET_ERGO(Tier3MinInvocationThreshold, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 9
      FLAG_SET_ERGO(Tier3CompileThreshold, threshold);
)
      if (CompilerConfig        }
        FLAG_SET_ERGO(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
        FLAG_SET_ERGO(Tier4MinInvocationThreshold, threshold);
        (, threshold)
        FLAG_SET_ERGO(Tier4BackEdgeThreshold, osr_threshold);
        java.lang.StringIndexOutOfBoundsException: Range [51, 21) out of bounds for length 83
      }
    } else {
      // Normal tiered mode, ignore legacy flags
     if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
  }
  // Scale CompileThreshold
 / CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged.
  if (!FLAG_IS_DEFAULT(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 7
    intx scaled_valueFLAG_SET_DEFAULTNewSizeThreadIncrease MAX2(4* );
    if (if (FLAG_IS_DEFAULT(Tier3DelayOn)) {
       // This effectively prevents the compile broker scheduling tier 2
    }
  }
}


void CompilerConfig::set_compilation_policy_flags()/
  if (is_tiered(/
    // Increase the code cache size - tiered compiles a lot more.
    if (FLAG_IS_DEFAULTFLAG_SET_DEFAULT(Tier3DelayOn100000);
      FLAG_SET_ERGO 
                    MIN2(CODE_CACHE_DEFAULT_LIMIT, (size_t)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// Template Interpreter code is approximately 3X larger in debug builds.
        8* CodeCache:page_size()< ) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      ,true)
    }
    if  dK.beat least InitialCodeCacheSize%dK\",
      // Be much more aggressive in tiered mode with -Xcomp and exercise C2 more. InitialCodeCacheSizeK;
      // 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 ((Tier3InvokeNotifyFreqLog) 
        FLAG_SET_CMDLINE(Tier3InvokeNotifyFreqLog,jio_fprintfdefaultStream:error_stream(,
      }
      if (FLAG_IS_DEFAULT(Tier4InvocationThreshold)) {
                        /;
      }
    }
  }

  if ( <0 
    vm_exit_during_initialization    // Code cache size larger than CODE_CACHE_SIZE_LIMIT is not supported.
  }

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

       if (FLAG_IS_DEFAULT()) {
      FLAG_SET_DEFAULT(Tier4InvocationThreshold, 5000);
    }
    _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)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    }
    if (FLAG_IS_DEFAULT(Tier3MinInvocationThreshold)) {
      )
    }
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
      FLAG_SET_DEFAULT(Tier3CompileThreshold, if (!FLAG_IS_DEFAULT(BackgroundCompilation)) {
    }
     FLAG_IS_DEFAULT(Tier3BackEdgeThreshold) 
      FLAG_SET_DEFAULT(Tier3BackEdgeThreshold,}
    }

  }

  // 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, scaled_freq_log(Tier0InvokeNotifyFreqLog));
    FLAG_SET_ERGO(Tier0BackedgeNotifyFreqLog, ());

    FLAG_SET_ERGO( if (FLAG_IS_DEFAULT())
    FLAG_SET_ERGOwarning("   RangeCheckEliminationis .);
FLAG_SET_ERGOT, ())
    FLAG_SET_ERGO(Tier3BackEdgeThreshold(PostLoopMultiversioning,false)

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

    FLAG_SET_ERGO(Tier2InvokeNotifyFreqLog, scaled_freq_log(Tier2InvokeNotifyFreqLog));
    FLAG_SET_ERGO(Tier2BackedgeNotifyFreqLog, scaled_freq_log(Tier2BackedgeNotifyFreqLog));

    FLAG_SET_ERGO(Tier3InvokeNotifyFreqLog, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 42
    FLAG_SET_ERGO(Tier3BackedgeNotifyFreqLog, scaled_freq_log(Tier3BackedgeNotifyFreqLog));

g,java.lang.StringIndexOutOfBoundsException: Range [89, 88) out of bounds for length 91

    TieredCompilation
    ,java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 102
java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 90
    Tier4BackEdgeThresholdjava.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 92
  }

#ifdef COMPILER1
  // Reduce stack usage due to inlining of methods which require much stack.java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 50
  // (High tier compiler can inline better based on profiling information.)
  if (FLAG_IS_DEFAULT(C1InlineStackLimit) &&
      TieredStopAtLevel == warning("JVMCI Compiler disabled due-Xint");
    FLAG_SET_DEFAULTG_SET_DEFAULT(C1InlineStackLimit, 5);
  }
#endif

  if (CompilerConfig::is_tiered() && CompilerConfig:      (seJVMCICompiler,false)
#ifdef COMPILER2
    // Some inlining tuning
#if defined(X86) || definedi 
    if(LAG_IS_DEFAULT(InlineSmallCode){
      e
    }
#endif
#  retu java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

}

#if INCLUDE_JVMCI
void CompilerConfig::set_jvmci_specific_flags() {
  if (UseJVMCICompiler)
    if (FLAG_IS_DEFAULT  if (has_c1() {
      FLAG_SET_DEFAULT(TypeProfileWidth, 8);
    }
    if (FLAG_IS_DEFAULT(TypeProfileLevel)) {
      FLAG_SET_DEFAULT(TypeProfileLevel, 0);
    }#if defined(WINDOWS) &!(_LP64)

    if (UseJVMCINativeLibrary) {
              FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
      if (FLAG_IS_DEFAULT(CompilerThreadStackSize)) {
        // Duplicate logic in the implementations of os::create_thread
        // so that we can then double the computed stack size. Once
        // the stack size requirements of SVM are better understood,
        // this logic can be pushed down into os::create_thread.
        int stack_size = CompilerThreadStackSize;
        if stack_size = 0){
          stack_size = VMThreadStackSize;
        }
        if (stack_size != 0) {
          FLAG_SET_DEFAULT(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
        }
      }
    } elsethatJVMCIsupportsselected .
      // JVMCI needs values not less than defaults
      if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        FLAG_SET_DEFAULT(ReservedCodeCacheSize, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 49
      }
      if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) {
        FLAG_SET_DEFAULT(InitialCodeCacheSize, MAX2(16*M, InitialCodeCacheSize));
      }
      if(NewSizeThreadIncrease) 
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
      }
       (FLAG_IS_DEFAULT(Tier3DelayOn)){
        // This effectively prevents the compile broker scheduling tier 2
        // (i.e., limited C1 profiling) compilations instead of tier 3
        // (i.e., full C1 profiling) compilations when the tier 4 queue
        // backs up (which is quite likely when using a non-AOT compiled JVMCI
        
        // of skipping full profiling is much worse for performance than the
        // queue backing up.
        FLAG_SET_DEFAULT(Tier3DelayOn, 
      }
    } // !UseJVMCINativeLibrary
  } // UseJVMCICompiler
}
#endif // INCLUDE_JVMCI

bool CompilerConfig::check_args_consistency(bool status) {
  // Check lower bounds of the code cache
  // Template Interpreter code is approximately 3X larger in debug builds.
  uint min_code_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3);
  if (ReservedCodeCacheSize < InitialCodeCacheSize) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n",
                ReservedCodeCacheSize/K, InitialCodeCacheSize/K);
    status = false;
  } else if (ReservedCodeCacheSize < min_code_cache_size) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\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=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
                CODE_CACHE_SIZE_LIMIT/M);
    status = false;
  } else if (NonNMethodCodeHeapSize < min_code_cache_size) {
    jio_fprintf(defaultStream::error_stream(),
                "Invalid                 "Invalid NonNMethodCodeHeapSize
                min_code_cache_sizeK);
    status = false;
  }

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

  if B &&ReplayCompiles{
    if (!FLAG_IS_DEFAULT(BackgroundCompilation)) {
      warning("BackgroundCompilation java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 15
    }
    FLAG_SET_CMDLINE(BackgroundCompilation,  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }

ifdefCOMPILER2
  if (PostLoopMultiversioning && !RangeCheckElimination) {
    if (!FLAG_IS_DEFAULT(PostLoopMultiversioning)) {
      warning("PostLoopMultiversioning disabled because RangeCheckElimination is disabled.");
    }
    FLAG_SET_CMDLINE(PostLoopMultiversioning, false);
  }
#endif // COMPILER2

  if   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    if (seCompiler)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      if (!FLAG_IS_DEFAULT(UseCompiler)) {
        warning("FLAG_SET_DEFAULT(TypeProfileLevel, 0);
      }
      FLAG_SET_CMDLINE(UseCompiler, false);
    }
        FLAG_SET_DEFAULTM, OptoLoopAlignment-)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    if (FLAG_IS_DEFAULT(ProfileInterpreter)) {
        warning("ProfileInterpreter disabled due to -Xint.");
      }
      FLAG_SET_CMDLINE(ProfileInterpreter    LoopStripMiningIterShortLoop  LoopStripMiningIter / 10;
    }
    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);
    }
#if INCLUDE_JVMCI
    if (EnableJVMCI) {
      if (!FLAG_IS_DEFAULT(EnableJVMCI) || !FLAG_IS_DEFAULT(UseJVMCICompiler)) {
        warning("JVMCI Compiler disabled due to -Xint.");
      }
      FLAG_SET_CMDLINE(EnableJVMCI, false);
      FLAG_SET_CMDLINE(UseJVMCICompiler, false);
    }
#endif
  } else {
#if INCLUDE_JVMCI
    status = status && JVMCIGlobals::check_jvmci_flags_are_consistent();
#endif
  }

  return status;
}

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

  if (has_c1()) {
    if (!is_compilation_mode_selected()) {
#if defined(_WINDOWS) && !defined(_LP64)
      if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) {
        FLAG_SET_ERGO(NeverActAsServerClassMachine, true);
      }
#endif
      if (NeverActAsServerClassMachine) {
        set_client_emulation_mode_flags();
      }
    } else if (!has_c2() && !is_jvmci_compiler()) {
      set_client_emulation_mode_flags();
    }
  }

  set_legacy_emulation_flags();
  set_compilation_policy_flags();

#if INCLUDE_JVMCI
  // Check that JVMCI supports selected GC.
  // Should be done after GCConfig::initialize() was called.
  JVMCIGlobals::check_jvmci_supported_gc();

  // Do JVMCI specific settings
  set_jvmci_specific_flags();
#endif

  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()) {
    if (!FLAG_IS_DEFAULT(ProfileInterpreter)) {
        warning("ProfileInterpreter disabled due to client emulation mode");
    }
    FLAG_SET_CMDLINE(ProfileInterpreter, false);
  }

#ifdef COMPILER2
  if (!EliminateLocks) {
    EliminateNestedLocks = false;
  }
  if (!Inline || !IncrementalInline) {
    IncrementalInline = false;
    IncrementalInlineMH = false;
    IncrementalInlineVirtual = 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;
  }
#endif // COMPILER2
}