src/share/vm/runtime/globals.cpp

*** 21,31 ****
--- 21,33 ----
   * questions.
   *
   */
  
  #include "precompiled.hpp"
+ #if INCLUDE_JFR
  #include "jfr/jfrEvents.hpp"
+ #endif
  #include "memory/allocation.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/arguments.hpp"
  #include "runtime/globals.hpp"
  #include "runtime/globals_extension.hpp"
*** 627,647 ****
--- 629,653 ----
  bool CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_bool()) return false;
    bool old_value = result->get_bool();
+ #if INCLUDE_JFR
    trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
+ #endif
    result->set_bool(*value);
    *value = old_value;
    result->set_origin(origin);
    return true;
  }
  
  void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
+ #if INCLUDE_JFR
    trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
+ #endif
    faddr->set_bool(value);
    faddr->set_origin(origin);
  }
  
  bool CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
*** 655,675 ****
--- 661,685 ----
  bool CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_intx()) return false;
    intx old_value = result->get_intx();
+ #if INCLUDE_JFR
    trace_flag_changed<EventLongFlagChanged, s8>(name, old_value, *value, origin);
+ #endif
    result->set_intx(*value);
    *value = old_value;
    result->set_origin(origin);
    return true;
  }
  
  void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
+ #if INCLUDE_JFR
    trace_flag_changed<EventLongFlagChanged, s8>(faddr->_name, faddr->get_intx(), value, origin);
+ #endif
    faddr->set_intx(value);
    faddr->set_origin(origin);
  }
  
  bool CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
*** 683,703 ****
--- 693,717 ----
  bool CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_uintx()) return false;
    uintx old_value = result->get_uintx();
+ #if INCLUDE_JFR
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
+ #endif
    result->set_uintx(*value);
    *value = old_value;
    result->set_origin(origin);
    return true;
  }
  
  void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
+ #if INCLUDE_JFR
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
+ #endif
    faddr->set_uintx(value);
    faddr->set_origin(origin);
  }
  
  bool CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
*** 711,731 ****
--- 725,749 ----
  bool CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_uint64_t()) return false;
    uint64_t old_value = result->get_uint64_t();
+ #if INCLUDE_JFR
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
+ #endif
    result->set_uint64_t(*value);
    *value = old_value;
    result->set_origin(origin);
    return true;
  }
  
  void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
+ #if INCLUDE_JFR
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
+ #endif
    faddr->set_uint64_t(value);
    faddr->set_origin(origin);
  }
  
  bool CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
*** 739,759 ****
--- 757,781 ----
  bool CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_double()) return false;
    double old_value = result->get_double();
+ #if INCLUDE_JFR
    trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
+ #endif
    result->set_double(*value);
    *value = old_value;
    result->set_origin(origin);
    return true;
  }
  
  void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
+ #if INCLUDE_JFR
    trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
+ #endif
    faddr->set_double(value);
    faddr->set_origin(origin);
  }
  
  bool CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
*** 767,777 ****
--- 789,801 ----
  bool CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return false;
    if (!result->is_ccstr()) return false;
    ccstr old_value = result->get_ccstr();
+ #if INCLUDE_JFR
    trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin);
+ #endif
    char* new_value = NULL;
    if (*value != NULL) {
      new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal);
      strcpy(new_value, *value);
    }
*** 789,799 ****
--- 813,825 ----
  
  void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
    ccstr old_value = faddr->get_ccstr();
+ #if INCLUDE_JFR
    trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin);
+ #endif
    char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
    strcpy(new_value, value);
    faddr->set_ccstr(new_value);
    if (!faddr->is_default() && old_value != NULL) {
      // Prior value is heap allocated so free it.