changeset 8522:8597e296c18b

8080947: Add uint as a valid VM flag type Reviewed-by: brutisso, ddmitriev
author david
date Thu, 04 Jun 2015 14:29:34 +0200
parents 394e2a24dff2
children cbadc6df922b 01d947f8d411
files agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java src/share/vm/gc/parallel/psMarkSweep.cpp src/share/vm/gc/shared/collectorPolicy.cpp src/share/vm/prims/whitebox.cpp src/share/vm/runtime/arguments.cpp src/share/vm/runtime/globals.cpp src/share/vm/runtime/globals.hpp src/share/vm/runtime/globals_extension.hpp src/share/vm/services/management.cpp src/share/vm/services/writeableFlags.cpp src/share/vm/services/writeableFlags.hpp src/share/vm/trace/trace.xml
diffstat 12 files changed, 278 insertions(+), 5 deletions(-) [+]
line wrap: on
line diff
--- a/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Thu Jun 04 14:19:51 2015 +0200
+++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Thu Jun 04 14:29:34 2015 +0200
@@ -121,6 +121,8 @@
   private Flag[] commandLineFlags;
   private Map flagsMap;
 
+  private static Type intType;
+  private static Type uintType;
   private static Type intxType;
   private static Type uintxType;
   private static Type sizetType;
@@ -170,6 +172,28 @@
         return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) != 0;
      }
 
+     public boolean isInt() {
+        return type.equals("int");
+     }
+
+     public long getInt() {
+        if (Assert.ASSERTS_ENABLED) {
+           Assert.that(isInt(), "not an int flag!");
+        }
+        return addr.getCIntegerAt(0, intType.getSize(), false);
+     }
+
+     public boolean isUInt() {
+        return type.equals("uint");
+     }
+
+     public long getUInt() {
+        if (Assert.ASSERTS_ENABLED) {
+           Assert.that(isUInt(), "not a uint flag!");
+        }
+        return addr.getCIntegerAt(0, uintType.getSize(), false);
+     }
+
      public boolean isIntx() {
         return type.equals("intx");
      }
@@ -206,6 +230,10 @@
      public String getValue() {
         if (isBool()) {
            return new Boolean(getBool()).toString();
+        } else if (isInt()) {
+           return new Long(getInt()).toString();
+        } else if (isUInt()) {
+           return new Long(getUInt()).toString();
         } else if (isIntx()) {
            return new Long(getIntx()).toString();
         } else if (isUIntx()) {
@@ -334,6 +362,8 @@
     heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
     oopSize  = db.lookupIntConstant("oopSize").intValue();
 
+    intType = db.lookupType("int");
+    uintType = db.lookupType("uint");
     intxType = db.lookupType("intx");
     uintxType = db.lookupType("uintx");
     sizetType = db.lookupType("size_t");
--- a/src/share/vm/gc/parallel/psMarkSweep.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/gc/parallel/psMarkSweep.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -96,7 +96,7 @@
     heap->collector_policy()->should_clear_all_soft_refs();
 
   uint count = maximum_heap_compaction ? 1 : MarkSweepAlwaysCompactCount;
-  UIntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count);
+  UIntXFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count);
   PSMarkSweep::invoke_no_policy(clear_all_soft_refs || maximum_heap_compaction);
 }
 
--- a/src/share/vm/gc/shared/collectorPolicy.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/gc/shared/collectorPolicy.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -785,7 +785,7 @@
   // free memory should be here, especially if they are expensive. If this
   // attempt fails, an OOM exception will be thrown.
   {
-    UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
+    UIntXFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
 
     gch->do_collection(true             /* full */,
                        true             /* clear_all_soft_refs */,
--- a/src/share/vm/prims/whitebox.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/prims/whitebox.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -710,6 +710,24 @@
   return NULL;
 WB_END
 
+WB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name))
+  int result;
+  if (GetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAt)) {
+    ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
+    return longBox(thread, env, result);
+  }
+  return NULL;
+WB_END
+
+WB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name))
+  uint result;
+  if (GetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAt)) {
+    ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
+    return longBox(thread, env, result);
+  }
+  return NULL;
+WB_END
+
 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
   intx result;
   if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {
@@ -771,6 +789,16 @@
   SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);
 WB_END
 
+WB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
+  int result = value;
+  SetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAtPut);
+WB_END
+
+WB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
+  uint result = value;
+  SetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAtPut);
+WB_END
+
 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
   intx result = value;
   SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);
@@ -1336,6 +1364,8 @@
   {CC"isConstantVMFlag",   CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
   {CC"isLockedVMFlag",     CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
   {CC"setBooleanVMFlag",   CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
+  {CC"setIntVMFlag",       CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag},
+  {CC"setUintVMFlag",      CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag},
   {CC"setIntxVMFlag",      CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
   {CC"setUintxVMFlag",     CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
   {CC"setUint64VMFlag",    CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
@@ -1345,6 +1375,10 @@
                                                       (void*)&WB_SetStringVMFlag},
   {CC"getBooleanVMFlag",   CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
                                                       (void*)&WB_GetBooleanVMFlag},
+  {CC"getIntVMFlag",       CC"(Ljava/lang/String;)Ljava/lang/Long;",
+                                                      (void*)&WB_GetIntVMFlag},
+  {CC"getUintVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
+                                                      (void*)&WB_GetUintVMFlag},
   {CC"getIntxVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
                                                       (void*)&WB_GetIntxVMFlag},
   {CC"getUintxVMFlag",     CC"(Ljava/lang/String;)Ljava/lang/Long;",
--- a/src/share/vm/runtime/arguments.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/runtime/arguments.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -586,11 +586,12 @@
 
 static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) {
   julong v;
+  int int_v;
   intx intx_v;
   bool is_neg = false;
   // Check the sign first since atomull() parses only unsigned values.
   if (*value == '-') {
-    if (!CommandLineFlags::intxAt(name, &intx_v)) {
+    if (!CommandLineFlags::intxAt(name, &intx_v) && !CommandLineFlags::intAt(name, &int_v)) {
       return false;
     }
     value++;
@@ -599,6 +600,17 @@
   if (!atomull(value, &v)) {
     return false;
   }
+  int_v = (int) v;
+  if (is_neg) {
+    int_v = -int_v;
+  }
+  if (CommandLineFlags::intAtPut(name, &int_v, origin)) {
+    return true;
+  }
+  uint uint_v = (uint) v;
+  if (!is_neg && CommandLineFlags::uintAtPut(name, &uint_v, origin)) {
+    return true;
+  }
   intx_v = (intx) v;
   if (is_neg) {
     intx_v = -intx_v;
--- a/src/share/vm/runtime/globals.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/runtime/globals.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -93,6 +93,32 @@
   *((bool*) _addr) = value;
 }
 
+bool Flag::is_int() const {
+  return strcmp(_type, "int")  == 0;
+}
+
+int Flag::get_int() const {
+  return *((int*) _addr);
+}
+
+void Flag::set_int(int value) {
+  check_writable();
+  *((int*) _addr) = value;
+}
+
+bool Flag::is_uint() const {
+  return strcmp(_type, "uint")  == 0;
+}
+
+uint Flag::get_uint() const {
+  return *((uint*) _addr);
+}
+
+void Flag::set_uint(uint value) {
+  check_writable();
+  *((uint*) _addr) = value;
+}
+
 bool Flag::is_intx() const {
   return strcmp(_type, "intx")  == 0;
 }
@@ -316,6 +342,12 @@
   if (is_bool()) {
     st->print("%-16s", get_bool() ? "true" : "false");
   }
+  if (is_int()) {
+    st->print("%-16d", get_int());
+  }
+  if (is_uint()) {
+    st->print("%-16u", get_uint());
+  }
   if (is_intx()) {
     st->print("%-16ld", get_intx());
   }
@@ -411,6 +443,10 @@
 void Flag::print_as_flag(outputStream* st) {
   if (is_bool()) {
     st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
+  } else if (is_int()) {
+    st->print("-XX:%s=%d", _name, get_int());
+  } else if (is_uint()) {
+    st->print("-XX:%s=%u", _name, get_uint());
   } else if (is_intx()) {
     st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
   } else if (is_uintx()) {
@@ -663,6 +699,62 @@
   faddr->set_origin(origin);
 }
 
+bool CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
+  Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
+  if (result == NULL) return false;
+  if (!result->is_int()) return false;
+  *value = result->get_int();
+  return true;
+}
+
+bool CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
+  Flag* result = Flag::find_flag(name, len);
+  if (result == NULL) return false;
+  if (!result->is_int()) return false;
+  int old_value = result->get_int();
+  trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
+  result->set_int(*value);
+  *value = old_value;
+  result->set_origin(origin);
+  return true;
+}
+
+void CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
+  Flag* faddr = address_of_flag(flag);
+  guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
+  trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
+  faddr->set_int(value);
+  faddr->set_origin(origin);
+}
+
+bool CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
+  Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
+  if (result == NULL) return false;
+  if (!result->is_uint()) return false;
+  *value = result->get_uint();
+  return true;
+}
+
+bool CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
+  Flag* result = Flag::find_flag(name, len);
+  if (result == NULL) return false;
+  if (!result->is_uint()) return false;
+  uint old_value = result->get_uint();
+  trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
+  result->set_uint(*value);
+  *value = old_value;
+  result->set_origin(origin);
+  return true;
+}
+
+void CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
+  Flag* faddr = address_of_flag(flag);
+  guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
+  trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
+  faddr->set_uint(value);
+  faddr->set_origin(origin);
+}
+
 bool CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
   if (result == NULL) return false;
--- a/src/share/vm/runtime/globals.hpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/runtime/globals.hpp	Thu Jun 04 14:29:34 2015 +0200
@@ -279,6 +279,14 @@
   bool get_bool() const;
   void set_bool(bool value);
 
+  bool is_int() const;
+  int get_int() const;
+  void set_int(int value);
+
+  bool is_uint() const;
+  uint get_uint() const;
+  void set_uint(uint value);
+
   bool is_intx() const;
   intx get_intx() const;
   void set_intx(intx value);
@@ -363,13 +371,28 @@
   ~CounterSetting()         { (*counter)--; }
 };
 
+class IntFlagSetting {
+  int val;
+  int* flag;
+ public:
+  IntFlagSetting(int& fl, int newValue) { flag = &fl; val = fl; fl = newValue; }
+  ~IntFlagSetting()                     { *flag = val; }
+};
 
 class UIntFlagSetting {
+  uint val;
+  uint* flag;
+ public:
+  UIntFlagSetting(uint& fl, uint newValue) { flag = &fl; val = fl; fl = newValue; }
+  ~UIntFlagSetting()                       { *flag = val; }
+};
+
+class UIntXFlagSetting {
   uintx val;
   uintx* flag;
  public:
-  UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
-  ~UIntFlagSetting()                         { *flag = val; }
+  UIntXFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
+  ~UIntXFlagSetting()                         { *flag = val; }
 };
 
 class DoubleFlagSetting {
@@ -396,6 +419,16 @@
   static bool boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
   static bool boolAtPut(const char* name, bool* value, Flag::Flags origin)   { return boolAtPut(name, strlen(name), value, origin); }
 
+  static bool intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
+  static bool intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false)      { return intAt(name, strlen(name), value, allow_locked, return_flag); }
+  static bool intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
+  static bool intAtPut(const char* name, int* value, Flag::Flags origin)   { return intAtPut(name, strlen(name), value, origin); }
+
+  static bool uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
+  static bool uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false)      { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
+  static bool uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
+  static bool uintAtPut(const char* name, uint* value, Flag::Flags origin)   { return uintAtPut(name, strlen(name), value, origin); }
+
   static bool intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
   static bool intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false)      { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
   static bool intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
--- a/src/share/vm/runtime/globals_extension.hpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/runtime/globals_extension.hpp	Thu Jun 04 14:29:34 2015 +0200
@@ -197,6 +197,8 @@
 class CommandLineFlagsEx : CommandLineFlags {
  public:
   static void boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin);
+  static void intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin);
+  static void uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin);
   static void intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin);
   static void uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin);
   static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin);
--- a/src/share/vm/services/management.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/services/management.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -1558,6 +1558,12 @@
   if (flag->is_bool()) {
     global->value.z = flag->get_bool() ? JNI_TRUE : JNI_FALSE;
     global->type = JMM_VMGLOBAL_TYPE_JBOOLEAN;
+  } else if (flag->is_int()) {
+    global->value.j = (jlong)flag->get_int();
+    global->type = JMM_VMGLOBAL_TYPE_JLONG;
+  } else if (flag->is_uint()) {
+    global->value.j = (jlong)flag->get_uint();
+    global->type = JMM_VMGLOBAL_TYPE_JLONG;
   } else if (flag->is_intx()) {
     global->value.j = (jlong)flag->get_intx();
     global->type = JMM_VMGLOBAL_TYPE_JLONG;
--- a/src/share/vm/services/writeableFlags.cpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/services/writeableFlags.cpp	Thu Jun 04 14:29:34 2015 +0200
@@ -44,6 +44,36 @@
   return CommandLineFlags::boolAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
 }
 
+// set a int global flag
+int WriteableFlags::set_int_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+  int value;
+
+  if (sscanf(arg, "%d", &value)) {
+    return set_int_flag(name, value, origin, err_msg);
+  }
+  err_msg.print("flag value must be an integer");
+  return WRONG_FORMAT;
+}
+
+int WriteableFlags::set_int_flag(const char* name, int value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+  return CommandLineFlags::intAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
+}
+
+// set a uint global flag
+int WriteableFlags::set_uint_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+  uint value;
+
+  if (sscanf(arg, "%u", &value)) {
+    return set_uint_flag(name, value, origin, err_msg);
+  }
+  err_msg.print("flag value must be an unsigned integer");
+  return WRONG_FORMAT;
+}
+
+int WriteableFlags::set_uint_flag(const char* name, uint value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+  return CommandLineFlags::uintAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
+}
+
 // set a intx global flag
 int WriteableFlags::set_intx_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
   intx value;
@@ -173,6 +203,10 @@
   }
   if (f->is_bool()) {
     return set_bool_flag(f->_name, flag_value, origin, err_msg);
+  } else if (f->is_int()) {
+    return set_int_flag(f->_name, flag_value, origin, err_msg);
+  } else if (f->is_uint()) {
+    return set_uint_flag(f->_name, flag_value, origin, err_msg);
   } else if (f->is_intx()) {
     return set_intx_flag(f->_name, flag_value, origin, err_msg);
   } else if (f->is_uintx()) {
@@ -195,6 +229,12 @@
   if (f->is_bool()) {
     bool bvalue = (new_value.z == JNI_TRUE ? true : false);
     return set_bool_flag(f->_name, bvalue, origin, err_msg);
+  } else if (f->is_int()) {
+    int ivalue = (int)new_value.j;
+    return set_int_flag(f->_name, ivalue, origin, err_msg);
+  } else if (f->is_uint()) {
+    uint uvalue = (uint)new_value.j;
+    return set_uint_flag(f->_name, uvalue, origin, err_msg);
   } else if (f->is_intx()) {
     intx ivalue = (intx)new_value.j;
     return set_intx_flag(f->_name, ivalue, origin, err_msg);
--- a/src/share/vm/services/writeableFlags.hpp	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/services/writeableFlags.hpp	Thu Jun 04 14:29:34 2015 +0200
@@ -56,6 +56,10 @@
 
   // set a boolean global flag
   static int set_bool_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+  // set a int global flag
+  static int set_int_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+  // set a uint global flag
+  static int set_uint_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
   // set a intx global flag
   static int set_intx_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
   // set a uintx global flag
@@ -66,6 +70,10 @@
   static int set_size_t_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
   // set a boolean global flag
   static int set_bool_flag(const char* name, bool value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+  // set a int global flag
+  static int set_int_flag(const char* name, int value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+  // set a uint global flag
+  static int set_uint_flag(const char* name, uint value, Flag::Flags origin, FormatBuffer<80>& err_msg);
   // set a intx global flag
   static int set_intx_flag(const char* name, intx value, Flag::Flags origin, FormatBuffer<80>& err_msg);
   // set a uintx global flag
--- a/src/share/vm/trace/trace.xml	Thu Jun 04 14:19:51 2015 +0200
+++ b/src/share/vm/trace/trace.xml	Thu Jun 04 14:29:34 2015 +0200
@@ -122,6 +122,22 @@
       <value type="CLASS" field="definingClassLoader" label="Defining Class Loader"/>
     </event>
 
+    <event id="IntFlagChanged" path="vm/flag/int_changed" label="Int Flag Changed"
+          is_instant="true">
+      <value type="UTF8" field="name" label="Name" />
+      <value type="INTEGER" field="old_value" label="Old Value" />
+      <value type="INTEGER" field="new_value" label="New Value" />
+      <value type="FLAGVALUEORIGIN" field="origin" label="Origin" />
+    </event>
+
+    <event id="UnsignedIntFlagChanged" path="vm/flag/uint_changed" label="Unsigned Int Flag Changed"
+          is_instant="true">
+      <value type="UTF8" field="name" label="Name" />
+      <value type="UINT" field="old_value" label="Old Value" />
+      <value type="UINT" field="new_value" label="New Value" />
+      <value type="FLAGVALUEORIGIN" field="origin" label="Origin" />
+    </event>
+
     <event id="LongFlagChanged" path="vm/flag/long_changed" label="Long Flag Changed"
           is_instant="true">
       <value type="UTF8" field="name" label="Name" />