*** old/src/share/vm/prims/whitebox.cpp	Wed Nov  5 19:24:02 2014
--- new/src/share/vm/prims/whitebox.cpp	Wed Nov  5 19:24:02 2014

*** 35,47 ****
--- 35,49 ----
  #include "prims/whitebox.hpp"
  #include "prims/wbtestmethods/parserTests.hpp"
  
  #include "runtime/thread.hpp"
  #include "runtime/arguments.hpp"
+ #include "runtime/deoptimization.hpp"
  #include "runtime/interfaceSupport.hpp"
  #include "runtime/os.hpp"
  #include "runtime/vm_version.hpp"
+ #include "runtime/sweeper.hpp"
  
  #include "utilities/array.hpp"
  #include "utilities/debug.hpp"
  #include "utilities/macros.hpp"
  #include "utilities/exceptions.hpp"

*** 65,74 ****
--- 67,77 ----
  PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  
  #define SIZE_T_MAX_VALUE ((size_t) -1)
  
  bool WhiteBox::_used = false;
+ volatile bool WhiteBox::compilation_locked = false;
  
  WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
    return (jlong)(void*)JNIHandles::resolve(obj);
  WB_END
  

*** 306,316 ****
--- 309,318 ----
      MemTracker::record_virtual_memory_type((address)addr, mtTest);
  
    return addr;
  WB_END
  
  
  WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
    os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
    MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
  WB_END
  

*** 729,738 ****
--- 731,763 ----
      FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
    }
  WB_END
  
  
+ WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
+   WhiteBox::compilation_locked = true;
+ WB_END
+ 
+ WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
+   MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
+   WhiteBox::compilation_locked = false;
+   mo.notify_all();
+ WB_END
+ 
+ void WhiteBox::force_sweep() {
+   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
+   {
+     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+     NMethodSweeper::_should_sweep = true;
+   }
+   NMethodSweeper::possibly_sweep();
+ }
+ 
+ WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))
+   WhiteBox::force_sweep();
+ WB_END
+ 
  WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
    ResourceMark rm(THREAD);
    int len;
    jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
    return (StringTable::lookup(name, len) != NULL);

*** 775,784 ****
--- 800,838 ----
    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 enabled");
+   return CodeCache::get_code_heap(code)->code_blob_type();
+ }
+ 
+ CodeHeap* WhiteBox::get_code_heap(int blob_type) {
+   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
+   return CodeCache::get_code_heap(blob_type);
+ }
+ 
+ static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlob* cb) {
+   jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   jobjectArray result = env->NewObjectArray(3, 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, WhiteBox::get_blob_type(cb));
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   env->SetObjectArrayElement(result, 2, 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);

*** 791,821 ****
--- 845,935 ----
    int insts_size = code->insts_size();
  
    ThreadToNativeFromVM ttn(thread);
    jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
    CHECK_JNI_EXCEPTION_(env, NULL);
!   result = env->NewObjectArray(3, clazz, NULL);
!   result = env->NewObjectArray(4, clazz, NULL);
    if (result == NULL) {
      return result;
    }
  
+   jobjectArray codeBlob = codeBlob2objectArray(thread, env, code);
+   env->SetObjectArrayElement(result, 0, codeBlob);
+ 
    jobject level = integerBox(thread, env, code->comp_level());
    CHECK_JNI_EXCEPTION_(env, NULL);
!   env->SetObjectArrayElement(result, 0, level);
!   env->SetObjectArrayElement(result, 1, level);
  
    jbyteArray insts = env->NewByteArray(insts_size);
    CHECK_JNI_EXCEPTION_(env, NULL);
    env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
!   env->SetObjectArrayElement(result, 1, insts);
!   env->SetObjectArrayElement(result, 2, insts);
  
    jobject id = integerBox(thread, env, code->compile_id());
    CHECK_JNI_EXCEPTION_(env, NULL);
!   env->SetObjectArrayElement(result, 2, id);
!   env->SetObjectArrayElement(result, 3, id);
  
    return result;
  WB_END
  
+ CodeBlob* WhiteBox::allocateCodeHeap(int size, int blob_type) {
+   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
+   BufferBlob* blob;
+   int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
+   if (full_size < size) {
+     full_size += round_to(size - full_size, oopSize);
+   }
+   {
+     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+     blob = (BufferBlob*) CodeCache::allocate(full_size, blob_type);
+   }
+   // Track memory usage statistic after releasing CodeCache_lock
+   MemoryService::track_code_cache_memory_usage();
+   new (blob) BufferBlob("WB::DummyBlob", full_size);
+   return blob;
+ }
+ 
+ WB_ENTRY(jlong, WB_AllocateCodeHeap(JNIEnv* env, jobject o, jint size, jint blob_type))
+     return (jlong) WhiteBox::allocateCodeHeap(size, blob_type);
+ WB_END
+ 
+ WB_ENTRY(void, WB_FreeCodeHeap(JNIEnv* env, jobject o, jlong addr))
+     BufferBlob::free((BufferBlob*) addr);
+ WB_END
+ 
+ WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_type))
+   ResourceMark rm;
+   GrowableArray<CodeBlob*> blobs;
+   {
+     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+     CodeHeap* heap = WhiteBox::get_code_heap(blob_type);
+     if (heap == NULL) {
+       return NULL;
+     }
+     for (CodeBlob* cb = (CodeBlob*) heap->first();
+          cb != NULL; cb = (CodeBlob*) heap->next(cb)) {
+       blobs.append(cb);
+     }
+   }
+   ThreadToNativeFromVM ttn(thread);
+   jobjectArray result = NULL;
+   jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
+   CHECK_JNI_EXCEPTION_(env, NULL);
+   result = env->NewObjectArray(blobs.length(), clazz, NULL);
+   if (result == NULL) {
+     return result;
+   }
+   int i = 0;
+   for (GrowableArrayIterator<CodeBlob*> it = blobs.begin();
+        it != blobs.end(); ++it) {
+     jobjectArray obj = codeBlob2objectArray(thread, env, *it);
+     env->SetObjectArrayElement(result, i, obj);
+     ++i;
+   }
+   return result;
+ WB_END
+ 
  WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
    return (jlong) Thread::current()->stack_size();
  WB_END
  
  WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))

*** 1019,1028 ****
--- 1133,1144 ----
        CC"(Ljava/lang/reflect/Executable;Z)Z",         (void*)&WB_TestSetForceInlineMethod},
    {CC"enqueueMethodForCompilation",
        CC"(Ljava/lang/reflect/Executable;II)Z",        (void*)&WB_EnqueueMethodForCompilation},
    {CC"clearMethodState",
        CC"(Ljava/lang/reflect/Executable;)V",          (void*)&WB_ClearMethodState},
+   {CC"lockCompilation",    CC"()V",                   (void*)&WB_LockCompilation},
+   {CC"unlockCompilation",  CC"()V",                   (void*)&WB_UnlockCompilation},
    {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"setIntxVMFlag",      CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
    {CC"setUintxVMFlag",     CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},

*** 1056,1065 ****
--- 1172,1185 ----
    {CC"incMetaspaceCapacityUntilGC", CC"(J)J",         (void*)&WB_IncMetaspaceCapacityUntilGC },
    {CC"metaspaceCapacityUntilGC", CC"()J",             (void*)&WB_MetaspaceCapacityUntilGC },
    {CC"getCPUFeatures",     CC"()Ljava/lang/String;",  (void*)&WB_GetCPUFeatures     },
    {CC"getNMethod",         CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
                                                        (void*)&WB_GetNMethod         },
+   {CC"forceNMethodSweep",  CC"()V",                   (void*)&WB_ForceNMethodSweep  },
+   {CC"allocateCodeHeap",   CC"(II)J",                 (void*)&WB_AllocateCodeHeap   },
+   {CC"freeCodeHeap",       CC"(J)V",                  (void*)&WB_FreeCodeHeap       },
+   {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
    {CC"getThreadStackSize", CC"()J",                   (void*)&WB_GetThreadStackSize },
    {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
  };
  
  #undef CC