*** old/src/share/vm/runtime/commandLineFlagConstraintsGC.cpp	Tue Jun 16 15:48:02 2015
--- new/src/share/vm/runtime/commandLineFlagConstraintsGC.cpp	Tue Jun 16 15:48:01 2015

*** 24,35 ****
--- 24,33 ----
  
  #include "precompiled.hpp"
  #include "runtime/arguments.hpp"
  #include "runtime/commandLineFlagConstraintsGC.hpp"
  #include "runtime/globals.hpp"
  #include "runtime/java.hpp"
  #include "runtime/os.hpp"
  #include "utilities/defaultStream.hpp"
  
  #if INCLUDE_ALL_GCS
  #include "gc/g1/g1_globals.hpp"
  #endif // INCLUDE_ALL_GCS

*** 39,49 ****
--- 37,47 ----
  #ifdef COMPILER2
  #include "opto/c2_globals.hpp"
  #endif // COMPILER2
  
  Flag::Error MinHeapFreeRatioConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > MaxHeapFreeRatio)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
                    "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
                    *value, MaxHeapFreeRatio);

*** 53,63 ****
--- 51,61 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error MaxHeapFreeRatioConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value < MinHeapFreeRatio)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "MaxHeapFreeRatio (" UINTX_FORMAT ") must be greater than or "
                    "equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n",
                    *value, MinHeapFreeRatio);

*** 67,77 ****
--- 65,75 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error MinMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > MaxMetaspaceFreeRatio)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "MinMetaspaceFreeRatio (" UINTX_FORMAT ") must be less than or "
                    "equal to MaxMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
                    *value, MaxMetaspaceFreeRatio);

*** 81,91 ****
--- 79,89 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error MaxMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value < MinMetaspaceFreeRatio)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be greater than or "
                    "equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n",
                    *value, MinMetaspaceFreeRatio);

*** 106,116 ****
--- 104,114 ----
  }
  
  Flag::Error InitialTenuringThresholdConstraintFunc(bool verbose, uintx* value) {
    UseConcMarkSweepGCWorkaroundIfNeeded(*value, MaxTenuringThreshold);
  
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > MaxTenuringThreshold)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "InitialTenuringThreshold (" UINTX_FORMAT ") must be less than or "
                    "equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n",
                    *value, MaxTenuringThreshold);

*** 122,132 ****
--- 120,130 ----
  }
  
  Flag::Error MaxTenuringThresholdConstraintFunc(bool verbose, uintx* value) {
    UseConcMarkSweepGCWorkaroundIfNeeded(InitialTenuringThreshold, *value);
  
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value < InitialTenuringThreshold)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "MaxTenuringThreshold (" UINTX_FORMAT ") must be greater than or "
                    "equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n",
                    *value, InitialTenuringThreshold);

*** 138,148 ****
--- 136,146 ----
  }
  
  #if INCLUDE_ALL_GCS
  
  Flag::Error G1NewSizePercentConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > G1MaxNewSizePercent)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "G1NewSizePercent (" UINTX_FORMAT ") must be less than or "
                    "equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n",
                    *value, G1MaxNewSizePercent);

*** 152,162 ****
--- 150,160 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error G1MaxNewSizePercentConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value < G1NewSizePercent)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "G1MaxNewSizePercent (" UINTX_FORMAT ") must be greater than or "
                    "equal to G1NewSizePercent (" UINTX_FORMAT ")\n",
                    *value, G1NewSizePercent);

*** 168,178 ****
--- 166,176 ----
  }
  
  #endif // INCLUDE_ALL_GCS
  
  Flag::Error CMSOldPLABMinConstraintFunc(bool verbose, size_t* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > CMSOldPLABMax)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "CMSOldPLABMin (" SIZE_FORMAT ") must be less than or "
                    "equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
                    *value, CMSOldPLABMax);

*** 181,206 ****
--- 179,190 ----
    } else {
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error CMSOldPLABMaxConstraintFunc(bool verbose, size_t* value) {
    if ((CommandLineFlags::finishedInitializing() == true) && (*value < CMSOldPLABMax)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "CMSOldPLABMax (" SIZE_FORMAT ") must be greater than or "
                    "equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
                    *value, CMSOldPLABMax);
      }
      return Flag::VIOLATES_CONSTRAINT;
    } else {
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error CMSPrecleanDenominatorConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value <= CMSPrecleanNumerator)) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "CMSPrecleanDenominator (" UINTX_FORMAT ") must be strickly greater than "
                    "CMSPrecleanNumerator (" UINTX_FORMAT ")\n",
                    *value, CMSPrecleanNumerator);

*** 210,220 ****
--- 194,204 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error CMSPrecleanNumeratorConstraintFunc(bool verbose, uintx* value) {
-   if ((CommandLineFlags::finishedInitializing() == true) && (*value > (CMSPrecleanDenominator - 1))) {
      if (verbose == true) {
        jio_fprintf(defaultStream::error_stream(),
                    "CMSPrecleanNumerator (" UINTX_FORMAT ") must be less than or "
                    "equal to CMSPrecleanDenominator - 1 (" UINTX_FORMAT ")\n", *value,
                    CMSPrecleanDenominator - 1);

*** 224,234 ****
--- 208,218 ----
      return Flag::SUCCESS;
    }
  }
  
  Flag::Error SurvivorAlignmentInBytesConstraintFunc(bool verbose, intx* value) {
-   if (CommandLineFlags::finishedInitializing() == true) {
      if (*value != 0) {
        if (!is_power_of_2(*value)) {
          if (verbose == true) {
            jio_fprintf(defaultStream::error_stream(),
                      "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be power of 2\n",