506 template <typename T>

   507 static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*)) {

   508   if (name == NULL) {

   509     return false;

   510   }

   511   ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   512   const char* flag_name = env->GetStringUTFChars(name, NULL);

   513   bool result = (*TAt)(flag_name, value);

   514   env->ReleaseStringUTFChars(name, flag_name);

   515   return result;

   516 }

   517 

   518 template <typename T>

   519 static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {

   520   if (name == NULL) {

   521     return false;

   522   }

   523   ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   524   const char* flag_name = env->GetStringUTFChars(name, NULL);

   525   bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);

   526   env->ReleaseStringUTFChars(name, flag_name);

   527   return result;

   528 }

   529 

   530 template <typename T>

   531 static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {

   532   ResourceMark rm(thread);

   533   jclass clazz = env->FindClass(name->as_C_string());

   534   CHECK_JNI_EXCEPTION_(env, NULL);

   535   jmethodID methodID = env->GetStaticMethodID(clazz,

   536         vmSymbols::valueOf_name()->as_C_string(),

   537         sig->as_C_string());

   538   CHECK_JNI_EXCEPTION_(env, NULL);

   539   jobject result = env->CallStaticObjectMethod(clazz, methodID, value);

   540   CHECK_JNI_EXCEPTION_(env, NULL);

   541   return result;

   542 }

   543 

   544 static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) {

   545   return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value);

   546 }

   547 static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) {

   548   return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value);

   549 }

   550 static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) {

   551   return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value);

   552 }

   553 /* static jobject floatBox(JavaThread* thread, JNIEnv* env, jfloat value) {

   554   return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value);

   555 }*/

   556 static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {

   557   return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);

   558 }

   559 

   560 WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name))

   561   bool result;

   562   if (GetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAt)) {

   563     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   564     return booleanBox(thread, env, result);

   565   }

   566   return NULL;

   567 WB_END

   568 

   569 WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))

   570   intx result;

   571   if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {

   572     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   573     return longBox(thread, env, result);

   574   }

   575   return NULL;

   576 WB_END

   577 

   578 WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name))

   579   uintx result;

   580   if (GetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAt)) {

   581     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   582     return longBox(thread, env, result);

   583   }

   584   return NULL;

   585 WB_END

   586 

   587 WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name))

   588   uint64_t result;

   589   if (GetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAt)) {

   590     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   591     return longBox(thread, env, result);

   592   }

   593   return NULL;

   594 WB_END

   595 

   596 WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name))

   597   double result;

   598   if (GetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAt)) {

   599     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   600     return doubleBox(thread, env, result);

   601   }

   602   return NULL;

   603 WB_END

   604 

   605 WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name))

   606   ccstr ccstrResult;

   607   if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAt)) {

   608     ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   609     jstring result = env->NewStringUTF(ccstrResult);

   610     CHECK_JNI_EXCEPTION_(env, NULL);

   611     return result;

   612   }

   613   return NULL;

   614 WB_END

   615 

   616 WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value))

   617   bool result = value == JNI_TRUE ? true : false;

   618   SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);

   619 WB_END

   620 

   621 WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))

   622   intx result = value;

   623   SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);

   624 WB_END

   625 

   626 WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))

   627   uintx result = value;

   628   SetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAtPut);

   629 WB_END

   630 

   631 WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value))

   632   uint64_t result = value;

   633   SetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAtPut);

   634 WB_END

   635 

   636 WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value))

   637   double result = value;

   638   SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);

   639 WB_END

   640 

   641 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))

   642   ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI

   643   const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);

   644   ccstr ccstrResult = ccstrValue;

   645   bool needFree;

   646   {

   647     ThreadInVMfromNative ttvfn(thread); // back to VM

   648     needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);

   649   }

   650   if (value != NULL) {

   651     env->ReleaseStringUTFChars(value, ccstrValue);

   652   }

   653   if (needFree) {

   654     FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);

   655   }

   656 WB_END

   657 

   658