src/share/vm/prims/whitebox.cpp

rev 9034 : 8229401: Fix JFR code cache test failures

*** 38,47 ****
--- 38,48 ----
  
  #include "runtime/arguments.hpp"
  #include "runtime/interfaceSupport.hpp"
  #include "runtime/os.hpp"
  #include "utilities/array.hpp"
+ #include "utilities/align.hpp"
  #include "utilities/debug.hpp"
  #include "utilities/macros.hpp"
  #include "utilities/exceptions.hpp"
  
  #if INCLUDE_ALL_GCS
*** 651,667 ****
    icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold + 1);
    bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold + 1);
  WB_END
  
  template <typename T>
! static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*)) {
    if (name == NULL) {
      return false;
    }
    ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
    const char* flag_name = env->GetStringUTFChars(name, NULL);
!   bool result = (*TAt)(flag_name, value);
    env->ReleaseStringUTFChars(name, flag_name);
    return result;
  }
  
  template <typename T>
--- 652,668 ----
    icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold + 1);
    bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold + 1);
  WB_END
  
  template <typename T>
! static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*, bool, bool)) {
    if (name == NULL) {
      return false;
    }
    ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
    const char* flag_name = env->GetStringUTFChars(name, NULL);
!   bool result = (*TAt)(flag_name, value, true, true);
    env->ReleaseStringUTFChars(name, flag_name);
    return result;
  }
  
  template <typename T>
*** 849,858 ****
--- 850,900 ----
    CHECK_JNI_EXCEPTION_(env, NULL);
  
    return features_string;
  WB_END
  
+ int WhiteBox::get_blob_type(const CodeBlob* code) {
+   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
+   return CodeBlobType::All;;
+ }
+ 
+ struct CodeBlobStub {
+   CodeBlobStub(const CodeBlob* blob) :
+       name(os::strdup(blob->name())),
+       size(blob->size()),
+       blob_type(WhiteBox::get_blob_type(blob)),
+       address((jlong) blob) { }
+   ~CodeBlobStub() { os::free((void*) name); }
+   const char* const name;
+   const jint        size;
+   const jint        blob_type;
+   const jlong       address;
+ };
+ 
+ static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
+   jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   jobjectArray result = env->NewObjectArray(4, clazz, NULL);
+ 
+   jstring name = env->NewStringUTF(cb->name);
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   env->SetObjectArrayElement(result, 0, name);
+ 
+   jobject obj = integerBox(thread, env, cb->size);
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   env->SetObjectArrayElement(result, 1, obj);
+ 
+   obj = integerBox(thread, env, cb->blob_type);
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   env->SetObjectArrayElement(result, 2, obj);
+ 
+   obj = longBox(thread, env, cb->address);
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   env->SetObjectArrayElement(result, 3, obj);
+ 
+   return result;
+ }
  
  WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
    ResourceMark rm(THREAD);
    jmethodID jmid = reflected_method_to_jmid(thread, env, method);
    CHECK_JNI_EXCEPTION_(env, NULL);
*** 886,895 ****
--- 928,978 ----
    env->SetObjectArrayElement(result, 2, insts);
  
    return result;
  WB_END
  
+ CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
+   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
+   BufferBlob* blob;
+   int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
+   if (full_size < size) {
+     full_size += align_up(size - full_size, oopSize);
+   }
+   {
+     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+     blob = (BufferBlob*) CodeCache::allocate(full_size);
+     ::new (blob) BufferBlob("WB::DummyBlob", full_size);
+   }
+   // Track memory usage statistic after releasing CodeCache_lock
+   MemoryService::track_code_cache_memory_usage();
+   return blob;
+ }
+ 
+ WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
+   if (size < 0) {
+     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
+       err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
+   }
+   return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
+ WB_END
+ 
+ WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
+   if (addr == 0) {
+     return;
+   }
+   BufferBlob::free((BufferBlob*) addr);
+ WB_END
+ 
+ WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
+   if (addr == 0) {
+     THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
+       "WB_GetCodeBlob: addr is null");
+   }
+   ThreadToNativeFromVM ttn(thread);
+   CodeBlobStub stub((CodeBlob*) addr);
+   return codeBlob2objectArray(thread, env, &stub);
+ WB_END
  
  int WhiteBox::array_bytes_to_length(size_t bytes) {
    return Array<u1>::bytes_to_length(bytes);
  }
  
*** 1165,1174 ****
--- 1248,1260 ----
                                                        (void*)&WB_GetStringVMFlag},
    {CC"isInStringTable",    CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable  },
    {CC"fullGC",   CC"()V",                             (void*)&WB_FullGC },
    {CC"youngGC",  CC"()V",                             (void*)&WB_YoungGC },
    {CC"readReservedMemory", CC"()V",                   (void*)&WB_ReadReservedMemory },
+   {CC"allocateCodeBlob",   CC"(II)J",                 (void*)&WB_AllocateCodeBlob   },
+   {CC"freeCodeBlob",       CC"(J)V",                  (void*)&WB_FreeCodeBlob       },
+   {CC"getCodeBlob",        CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob        },
    {CC"allocateMetaspace",
       CC"(Ljava/lang/ClassLoader;J)J",                 (void*)&WB_AllocateMetaspace },
    {CC"freeMetaspace",
       CC"(Ljava/lang/ClassLoader;JJ)V",                (void*)&WB_FreeMetaspace },
    {CC"incMetaspaceCapacityUntilGC", CC"(J)J",         (void*)&WB_IncMetaspaceCapacityUntilGC },