< prev index next >

src/hotspot/share/prims/whitebox.cpp

Print this page
rev 60538 : imported patch jep387-all.patch


  29 #include "classfile/classLoaderDataGraph.hpp"
  30 #include "classfile/javaClasses.inline.hpp"
  31 #include "classfile/modules.hpp"
  32 #include "classfile/protectionDomainCache.hpp"
  33 #include "classfile/stringTable.hpp"
  34 #include "classfile/symbolTable.hpp"
  35 #include "code/codeCache.hpp"
  36 #include "compiler/compilationPolicy.hpp"
  37 #include "compiler/methodMatcher.hpp"
  38 #include "compiler/directivesParser.hpp"
  39 #include "gc/shared/concurrentGCBreakpoints.hpp"
  40 #include "gc/shared/gcConfig.hpp"
  41 #include "gc/shared/genArguments.hpp"
  42 #include "gc/shared/genCollectedHeap.hpp"
  43 #include "jvmtifiles/jvmtiEnv.hpp"
  44 #include "logging/log.hpp"
  45 #include "memory/filemap.hpp"
  46 #include "memory/heapShared.inline.hpp"
  47 #include "memory/metaspaceShared.hpp"
  48 #include "memory/metadataFactory.hpp"

  49 #include "memory/iterator.hpp"
  50 #include "memory/resourceArea.hpp"
  51 #include "memory/universe.hpp"
  52 #include "memory/oopFactory.hpp"
  53 #include "oops/array.hpp"
  54 #include "oops/compressedOops.hpp"
  55 #include "oops/constantPool.inline.hpp"
  56 #include "oops/method.inline.hpp"
  57 #include "oops/objArrayKlass.hpp"
  58 #include "oops/objArrayOop.inline.hpp"
  59 #include "oops/oop.inline.hpp"
  60 #include "oops/typeArrayOop.inline.hpp"
  61 #include "prims/resolvedMethodTable.hpp"
  62 #include "prims/wbtestmethods/parserTests.hpp"
  63 #include "prims/whitebox.inline.hpp"
  64 #include "runtime/arguments.hpp"
  65 #include "runtime/atomic.hpp"
  66 #include "runtime/deoptimization.hpp"
  67 #include "runtime/fieldDescriptor.inline.hpp"
  68 #include "runtime/flags/jvmFlag.hpp"
  69 #include "runtime/frame.inline.hpp"
  70 #include "runtime/handles.inline.hpp"
  71 #include "runtime/handshake.hpp"
  72 #include "runtime/interfaceSupport.inline.hpp"
  73 #include "runtime/javaCalls.hpp"
  74 #include "runtime/jniHandles.inline.hpp"
  75 #include "runtime/os.hpp"
  76 #include "runtime/sweeper.hpp"
  77 #include "runtime/synchronizer.hpp"
  78 #include "runtime/thread.hpp"
  79 #include "runtime/threadSMR.hpp"
  80 #include "runtime/vm_version.hpp"
  81 #include "services/memoryService.hpp"
  82 #include "utilities/align.hpp"
  83 #include "utilities/debug.hpp"
  84 #include "utilities/elfFile.hpp"
  85 #include "utilities/exceptions.hpp"
  86 #include "utilities/macros.hpp"

  87 #if INCLUDE_CDS
  88 #include "prims/cdsoffsets.hpp"
  89 #endif // INCLUDE_CDS
  90 #if INCLUDE_G1GC
  91 #include "gc/g1/g1Arguments.hpp"
  92 #include "gc/g1/g1CollectedHeap.inline.hpp"
  93 #include "gc/g1/g1ConcurrentMark.hpp"
  94 #include "gc/g1/g1ConcurrentMarkThread.hpp"
  95 #include "gc/g1/heapRegionRemSet.hpp"
  96 #include "gc/g1/heterogeneousHeapRegionManager.hpp"
  97 #endif // INCLUDE_G1GC
  98 #if INCLUDE_PARALLELGC
  99 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
 100 #endif // INCLUDE_PARALLELGC
 101 #if INCLUDE_NMT
 102 #include "services/mallocSiteTable.hpp"
 103 #include "services/memTracker.hpp"
 104 #include "utilities/nativeCallStack.hpp"
 105 #endif // INCLUDE_NMT
 106 #if INCLUDE_AOT


1673 WB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method))
1674   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1675   CHECK_JNI_EXCEPTION_(env, 0);
1676   methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1677   return (jlong) mh->method_data();
1678 WB_END
1679 
1680 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
1681   return (jlong) thread->stack_size();
1682 WB_END
1683 
1684 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
1685   return (jlong) thread->stack_available(os::current_stack_pointer()) - (jlong)JavaThread::stack_shadow_zone_size();
1686 WB_END
1687 
1688 
1689 int WhiteBox::array_bytes_to_length(size_t bytes) {
1690   return Array<u1>::bytes_to_length(bytes);
1691 }
1692 



























































1693 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
1694   if (size < 0) {
1695     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1696         err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
1697   }
1698 
1699   oop class_loader_oop = JNIHandles::resolve(class_loader);
1700   ClassLoaderData* cld = class_loader_oop != NULL
1701       ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop)
1702       : ClassLoaderData::the_null_class_loader_data();
1703 
1704   void* metadata = MetadataFactory::new_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
1705 
1706   return (jlong)(uintptr_t)metadata;
1707 WB_END
1708 
1709 WB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size))
1710   oop class_loader_oop = JNIHandles::resolve(class_loader);
1711   ClassLoaderData* cld = class_loader_oop != NULL
1712       ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop)
1713       : ClassLoaderData::the_null_class_loader_data();
1714 
1715   MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
1716 WB_END
1717 
1718 WB_ENTRY(void, WB_DefineModule(JNIEnv* env, jobject o, jobject module, jboolean is_open,
1719                                 jstring version, jstring location, jobjectArray packages))
1720   Modules::define_module(module, is_open, version, location, packages, CHECK);
1721 WB_END
1722 
1723 WB_ENTRY(void, WB_AddModuleExports(JNIEnv* env, jobject o, jobject from_module, jstring package, jobject to_module))
1724   Modules::add_module_exports_qualified(from_module, package, to_module, CHECK);
1725 WB_END
1726 
1727 WB_ENTRY(void, WB_AddModuleExportsToAllUnnamed(JNIEnv* env, jobject o, jclass module, jstring package))
1728   Modules::add_module_exports_to_all_unnamed(module, package, CHECK);
1729 WB_END
1730 
1731 WB_ENTRY(void, WB_AddModuleExportsToAll(JNIEnv* env, jobject o, jclass module, jstring package))
1732   Modules::add_module_exports(module, package, NULL, CHECK);
1733 WB_END
1734 
1735 WB_ENTRY(void, WB_AddReadsModule(JNIEnv* env, jobject o, jobject from_module, jobject source_module))
1736   Modules::add_reads_module(from_module, source_module, CHECK);
1737 WB_END


2418   {CC"getUintVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
2419                                                       (void*)&WB_GetUintVMFlag},
2420   {CC"getIntxVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
2421                                                       (void*)&WB_GetIntxVMFlag},
2422   {CC"getUintxVMFlag",     CC"(Ljava/lang/String;)Ljava/lang/Long;",
2423                                                       (void*)&WB_GetUintxVMFlag},
2424   {CC"getUint64VMFlag",    CC"(Ljava/lang/String;)Ljava/lang/Long;",
2425                                                       (void*)&WB_GetUint64VMFlag},
2426   {CC"getSizeTVMFlag",     CC"(Ljava/lang/String;)Ljava/lang/Long;",
2427                                                       (void*)&WB_GetSizeTVMFlag},
2428   {CC"getDoubleVMFlag",    CC"(Ljava/lang/String;)Ljava/lang/Double;",
2429                                                       (void*)&WB_GetDoubleVMFlag},
2430   {CC"getStringVMFlag",    CC"(Ljava/lang/String;)Ljava/lang/String;",
2431                                                       (void*)&WB_GetStringVMFlag},
2432   {CC"isInStringTable",    CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable  },
2433   {CC"fullGC",   CC"()V",                             (void*)&WB_FullGC },
2434   {CC"youngGC",  CC"()V",                             (void*)&WB_YoungGC },
2435   {CC"readReservedMemory", CC"()V",                   (void*)&WB_ReadReservedMemory },
2436   {CC"allocateMetaspace",
2437      CC"(Ljava/lang/ClassLoader;J)J",                 (void*)&WB_AllocateMetaspace },
2438   {CC"freeMetaspace",
2439      CC"(Ljava/lang/ClassLoader;JJ)V",                (void*)&WB_FreeMetaspace },
2440   {CC"incMetaspaceCapacityUntilGC", CC"(J)J",         (void*)&WB_IncMetaspaceCapacityUntilGC },
2441   {CC"metaspaceCapacityUntilGC", CC"()J",             (void*)&WB_MetaspaceCapacityUntilGC },
2442   {CC"metaspaceReserveAlignment", CC"()J",            (void*)&WB_MetaspaceReserveAlignment },
2443   {CC"getCPUFeatures",     CC"()Ljava/lang/String;",  (void*)&WB_GetCPUFeatures     },
2444   {CC"getNMethod0",         CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
2445                                                       (void*)&WB_GetNMethod         },
2446   {CC"forceNMethodSweep",  CC"()V",                   (void*)&WB_ForceNMethodSweep  },
2447   {CC"allocateCodeBlob",   CC"(II)J",                 (void*)&WB_AllocateCodeBlob   },
2448   {CC"freeCodeBlob",       CC"(J)V",                  (void*)&WB_FreeCodeBlob       },
2449   {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
2450   {CC"getCompilationActivityMode",
2451                            CC"()I",                   (void*)&WB_GetCompilationActivityMode},
2452   {CC"getMethodData0",     CC"(Ljava/lang/reflect/Executable;)J",
2453                                                       (void*)&WB_GetMethodData      },
2454   {CC"getCodeBlob",        CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob        },
2455   {CC"getThreadStackSize", CC"()J",                   (void*)&WB_GetThreadStackSize },
2456   {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
2457   {CC"DefineModule",       CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2458                                                       (void*)&WB_DefineModule },
2459   {CC"AddModuleExports",   CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",


2516   {CC"isGCSelected",              CC"(I)Z",           (void*)&WB_IsGCSelected},
2517   {CC"isGCSelectedErgonomically", CC"()Z",            (void*)&WB_IsGCSelectedErgonomically},
2518   {CC"supportsConcurrentGCBreakpoints", CC"()Z",      (void*)&WB_SupportsConcurrentGCBreakpoints},
2519   {CC"concurrentGCAcquireControl0", CC"()V",          (void*)&WB_ConcurrentGCAcquireControl},
2520   {CC"concurrentGCReleaseControl0", CC"()V",          (void*)&WB_ConcurrentGCReleaseControl},
2521   {CC"concurrentGCRunToIdle0",    CC"()V",            (void*)&WB_ConcurrentGCRunToIdle},
2522   {CC"concurrentGCRunTo0",        CC"(Ljava/lang/String;)Z",
2523                                                       (void*)&WB_ConcurrentGCRunTo},
2524   {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
2525                                                       (void*)&WB_CheckLibSpecifiesNoexecstack},
2526   {CC"isContainerized",           CC"()Z",            (void*)&WB_IsContainerized },
2527   {CC"validateCgroup",
2528       CC"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I",
2529                                                       (void*)&WB_ValidateCgroup },
2530   {CC"printOsInfo",               CC"()V",            (void*)&WB_PrintOsInfo },
2531   {CC"disableElfSectionCache",    CC"()V",            (void*)&WB_DisableElfSectionCache },
2532   {CC"resolvedMethodItemsCount",  CC"()J",            (void*)&WB_ResolvedMethodItemsCount },
2533   {CC"protectionDomainRemovedCount",   CC"()I",       (void*)&WB_ProtectionDomainRemovedCount },
2534   {CC"aotLibrariesCount", CC"()I",                    (void*)&WB_AotLibrariesCount },
2535   {CC"getKlassMetadataSize", CC"(Ljava/lang/Class;)I",(void*)&WB_GetKlassMetadataSize},













2536 };
2537 
2538 
2539 #undef CC
2540 
2541 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
2542   {
2543     if (WhiteBoxAPI) {
2544       // Make sure that wbclass is loaded by the null classloader
2545       InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(wbclass)));
2546       Handle loader(THREAD, ik->class_loader());
2547       if (loader.is_null()) {
2548         WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
2549         WhiteBox::set_used();
2550       }
2551     }
2552   }
2553 JVM_END


  29 #include "classfile/classLoaderDataGraph.hpp"
  30 #include "classfile/javaClasses.inline.hpp"
  31 #include "classfile/modules.hpp"
  32 #include "classfile/protectionDomainCache.hpp"
  33 #include "classfile/stringTable.hpp"
  34 #include "classfile/symbolTable.hpp"
  35 #include "code/codeCache.hpp"
  36 #include "compiler/compilationPolicy.hpp"
  37 #include "compiler/methodMatcher.hpp"
  38 #include "compiler/directivesParser.hpp"
  39 #include "gc/shared/concurrentGCBreakpoints.hpp"
  40 #include "gc/shared/gcConfig.hpp"
  41 #include "gc/shared/genArguments.hpp"
  42 #include "gc/shared/genCollectedHeap.hpp"
  43 #include "jvmtifiles/jvmtiEnv.hpp"
  44 #include "logging/log.hpp"
  45 #include "memory/filemap.hpp"
  46 #include "memory/heapShared.inline.hpp"
  47 #include "memory/metaspaceShared.hpp"
  48 #include "memory/metadataFactory.hpp"
  49 #include "memory/metaspace/metaspace_test.hpp"
  50 #include "memory/iterator.hpp"
  51 #include "memory/resourceArea.hpp"
  52 #include "memory/universe.hpp"
  53 #include "memory/oopFactory.hpp"
  54 #include "oops/array.hpp"
  55 #include "oops/compressedOops.hpp"
  56 #include "oops/constantPool.inline.hpp"
  57 #include "oops/method.inline.hpp"
  58 #include "oops/objArrayKlass.hpp"
  59 #include "oops/objArrayOop.inline.hpp"
  60 #include "oops/oop.inline.hpp"
  61 #include "oops/typeArrayOop.inline.hpp"
  62 #include "prims/resolvedMethodTable.hpp"
  63 #include "prims/wbtestmethods/parserTests.hpp"
  64 #include "prims/whitebox.inline.hpp"
  65 #include "runtime/arguments.hpp"
  66 #include "runtime/atomic.hpp"
  67 #include "runtime/deoptimization.hpp"
  68 #include "runtime/fieldDescriptor.inline.hpp"
  69 #include "runtime/flags/jvmFlag.hpp"
  70 #include "runtime/frame.inline.hpp"
  71 #include "runtime/handles.inline.hpp"
  72 #include "runtime/handshake.hpp"
  73 #include "runtime/interfaceSupport.inline.hpp"
  74 #include "runtime/javaCalls.hpp"
  75 #include "runtime/jniHandles.inline.hpp"
  76 #include "runtime/os.hpp"
  77 #include "runtime/sweeper.hpp"
  78 #include "runtime/synchronizer.hpp"
  79 #include "runtime/thread.hpp"
  80 #include "runtime/threadSMR.hpp"
  81 #include "runtime/vm_version.hpp"
  82 #include "services/memoryService.hpp"
  83 #include "utilities/align.hpp"
  84 #include "utilities/debug.hpp"
  85 #include "utilities/elfFile.hpp"
  86 #include "utilities/exceptions.hpp"
  87 #include "utilities/macros.hpp"
  88 #include "utilities/ostream.hpp"
  89 #if INCLUDE_CDS
  90 #include "prims/cdsoffsets.hpp"
  91 #endif // INCLUDE_CDS
  92 #if INCLUDE_G1GC
  93 #include "gc/g1/g1Arguments.hpp"
  94 #include "gc/g1/g1CollectedHeap.inline.hpp"
  95 #include "gc/g1/g1ConcurrentMark.hpp"
  96 #include "gc/g1/g1ConcurrentMarkThread.hpp"
  97 #include "gc/g1/heapRegionRemSet.hpp"
  98 #include "gc/g1/heterogeneousHeapRegionManager.hpp"
  99 #endif // INCLUDE_G1GC
 100 #if INCLUDE_PARALLELGC
 101 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
 102 #endif // INCLUDE_PARALLELGC
 103 #if INCLUDE_NMT
 104 #include "services/mallocSiteTable.hpp"
 105 #include "services/memTracker.hpp"
 106 #include "utilities/nativeCallStack.hpp"
 107 #endif // INCLUDE_NMT
 108 #if INCLUDE_AOT


1675 WB_ENTRY(jlong, WB_GetMethodData(JNIEnv* env, jobject wv, jobject method))
1676   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
1677   CHECK_JNI_EXCEPTION_(env, 0);
1678   methodHandle mh(thread, Method::checked_resolve_jmethod_id(jmid));
1679   return (jlong) mh->method_data();
1680 WB_END
1681 
1682 WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
1683   return (jlong) thread->stack_size();
1684 WB_END
1685 
1686 WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
1687   return (jlong) thread->stack_available(os::current_stack_pointer()) - (jlong)JavaThread::stack_shadow_zone_size();
1688 WB_END
1689 
1690 
1691 int WhiteBox::array_bytes_to_length(size_t bytes) {
1692   return Array<u1>::bytes_to_length(bytes);
1693 }
1694 
1695 ///////////////
1696 // MetaspaceTestContext and MetaspaceTestArena
1697 WB_ENTRY(jlong, WB_CreateMetaspaceTestContext(JNIEnv* env, jobject wb, jlong commit_limit, jlong reserve_limit))
1698   metaspace::MetaspaceTestContext* context =
1699       new metaspace::MetaspaceTestContext("whitebox-metaspace-context", (size_t) commit_limit, (size_t) reserve_limit);
1700   return (jlong)p2i(context);
1701 WB_END
1702 
1703 WB_ENTRY(void, WB_DestroyMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context))
1704   delete (metaspace::MetaspaceTestContext*) context;
1705 WB_END
1706 
1707 WB_ENTRY(void, WB_PurgeMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context))
1708   metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context;
1709   context0->purge_area();
1710 WB_END
1711 
1712 WB_ENTRY(void, WB_PrintMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context))
1713   metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context;
1714   context0->print_on(tty);
1715 WB_END
1716 
1717 WB_ENTRY(jlong, WB_GetTotalCommittedWordsInMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context))
1718   metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context;
1719   return context0->committed_words();
1720 WB_END
1721 
1722 WB_ENTRY(jlong, WB_GetTotalUsedWordsInMetaspaceTestContext(JNIEnv* env, jobject wb, jlong context))
1723   metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context;
1724   return context0->used_words();
1725 WB_END
1726 
1727 WB_ENTRY(jlong, WB_CreateArenaInTestContext(JNIEnv* env, jobject wb, jlong context, jboolean is_micro))
1728   const Metaspace::MetaspaceType type = is_micro ? Metaspace::ReflectionMetaspaceType : Metaspace::StandardMetaspaceType;
1729   metaspace::MetaspaceTestContext* context0 = (metaspace::MetaspaceTestContext*) context;
1730   return (jlong)p2i(context0->create_arena(type));
1731 WB_END
1732 
1733 WB_ENTRY(void, WB_DestroyMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena))
1734   delete (metaspace::MetaspaceTestArena*) arena;
1735 WB_END
1736 
1737 WB_ENTRY(jlong, WB_AllocateFromMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena, jlong word_size))
1738   metaspace::MetaspaceTestArena* arena0 = (metaspace::MetaspaceTestArena*) arena;
1739   MetaWord* p = arena0->allocate((size_t) word_size);
1740   return (jlong)p2i(p);
1741 WB_END
1742 
1743 WB_ENTRY(void, WB_DeallocateToMetaspaceTestArena(JNIEnv* env, jobject wb, jlong arena, jlong p, jlong word_size))
1744   metaspace::MetaspaceTestArena* arena0 = (metaspace::MetaspaceTestArena*) arena;
1745   arena0->deallocate((MetaWord*)p, (size_t) word_size);
1746 WB_END
1747 
1748 WB_ENTRY(jlong, WB_GetMaxMetaspaceAllocationSize(JNIEnv* env, jobject wb))
1749   return (jlong) Metaspace::max_allocation_word_size() * BytesPerWord;
1750 WB_END
1751 
1752 //////////////
1753 
1754 WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
1755   if (size < 0) {
1756     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1757         err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
1758   }
1759 
1760   oop class_loader_oop = JNIHandles::resolve(class_loader);
1761   ClassLoaderData* cld = class_loader_oop != NULL
1762       ? java_lang_ClassLoader::loader_data_acquire(class_loader_oop)
1763       : ClassLoaderData::the_null_class_loader_data();
1764 
1765   void* metadata = MetadataFactory::new_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
1766 
1767   return (jlong)(uintptr_t)metadata;
1768 WB_END
1769 









1770 WB_ENTRY(void, WB_DefineModule(JNIEnv* env, jobject o, jobject module, jboolean is_open,
1771                                 jstring version, jstring location, jobjectArray packages))
1772   Modules::define_module(module, is_open, version, location, packages, CHECK);
1773 WB_END
1774 
1775 WB_ENTRY(void, WB_AddModuleExports(JNIEnv* env, jobject o, jobject from_module, jstring package, jobject to_module))
1776   Modules::add_module_exports_qualified(from_module, package, to_module, CHECK);
1777 WB_END
1778 
1779 WB_ENTRY(void, WB_AddModuleExportsToAllUnnamed(JNIEnv* env, jobject o, jclass module, jstring package))
1780   Modules::add_module_exports_to_all_unnamed(module, package, CHECK);
1781 WB_END
1782 
1783 WB_ENTRY(void, WB_AddModuleExportsToAll(JNIEnv* env, jobject o, jclass module, jstring package))
1784   Modules::add_module_exports(module, package, NULL, CHECK);
1785 WB_END
1786 
1787 WB_ENTRY(void, WB_AddReadsModule(JNIEnv* env, jobject o, jobject from_module, jobject source_module))
1788   Modules::add_reads_module(from_module, source_module, CHECK);
1789 WB_END


2470   {CC"getUintVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
2471                                                       (void*)&WB_GetUintVMFlag},
2472   {CC"getIntxVMFlag",      CC"(Ljava/lang/String;)Ljava/lang/Long;",
2473                                                       (void*)&WB_GetIntxVMFlag},
2474   {CC"getUintxVMFlag",     CC"(Ljava/lang/String;)Ljava/lang/Long;",
2475                                                       (void*)&WB_GetUintxVMFlag},
2476   {CC"getUint64VMFlag",    CC"(Ljava/lang/String;)Ljava/lang/Long;",
2477                                                       (void*)&WB_GetUint64VMFlag},
2478   {CC"getSizeTVMFlag",     CC"(Ljava/lang/String;)Ljava/lang/Long;",
2479                                                       (void*)&WB_GetSizeTVMFlag},
2480   {CC"getDoubleVMFlag",    CC"(Ljava/lang/String;)Ljava/lang/Double;",
2481                                                       (void*)&WB_GetDoubleVMFlag},
2482   {CC"getStringVMFlag",    CC"(Ljava/lang/String;)Ljava/lang/String;",
2483                                                       (void*)&WB_GetStringVMFlag},
2484   {CC"isInStringTable",    CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable  },
2485   {CC"fullGC",   CC"()V",                             (void*)&WB_FullGC },
2486   {CC"youngGC",  CC"()V",                             (void*)&WB_YoungGC },
2487   {CC"readReservedMemory", CC"()V",                   (void*)&WB_ReadReservedMemory },
2488   {CC"allocateMetaspace",
2489      CC"(Ljava/lang/ClassLoader;J)J",                 (void*)&WB_AllocateMetaspace },


2490   {CC"incMetaspaceCapacityUntilGC", CC"(J)J",         (void*)&WB_IncMetaspaceCapacityUntilGC },
2491   {CC"metaspaceCapacityUntilGC", CC"()J",             (void*)&WB_MetaspaceCapacityUntilGC },
2492   {CC"metaspaceReserveAlignment", CC"()J",            (void*)&WB_MetaspaceReserveAlignment },
2493   {CC"getCPUFeatures",     CC"()Ljava/lang/String;",  (void*)&WB_GetCPUFeatures     },
2494   {CC"getNMethod0",         CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
2495                                                       (void*)&WB_GetNMethod         },
2496   {CC"forceNMethodSweep",  CC"()V",                   (void*)&WB_ForceNMethodSweep  },
2497   {CC"allocateCodeBlob",   CC"(II)J",                 (void*)&WB_AllocateCodeBlob   },
2498   {CC"freeCodeBlob",       CC"(J)V",                  (void*)&WB_FreeCodeBlob       },
2499   {CC"getCodeHeapEntries", CC"(I)[Ljava/lang/Object;",(void*)&WB_GetCodeHeapEntries },
2500   {CC"getCompilationActivityMode",
2501                            CC"()I",                   (void*)&WB_GetCompilationActivityMode},
2502   {CC"getMethodData0",     CC"(Ljava/lang/reflect/Executable;)J",
2503                                                       (void*)&WB_GetMethodData      },
2504   {CC"getCodeBlob",        CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob        },
2505   {CC"getThreadStackSize", CC"()J",                   (void*)&WB_GetThreadStackSize },
2506   {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
2507   {CC"DefineModule",       CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2508                                                       (void*)&WB_DefineModule },
2509   {CC"AddModuleExports",   CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",


2566   {CC"isGCSelected",              CC"(I)Z",           (void*)&WB_IsGCSelected},
2567   {CC"isGCSelectedErgonomically", CC"()Z",            (void*)&WB_IsGCSelectedErgonomically},
2568   {CC"supportsConcurrentGCBreakpoints", CC"()Z",      (void*)&WB_SupportsConcurrentGCBreakpoints},
2569   {CC"concurrentGCAcquireControl0", CC"()V",          (void*)&WB_ConcurrentGCAcquireControl},
2570   {CC"concurrentGCReleaseControl0", CC"()V",          (void*)&WB_ConcurrentGCReleaseControl},
2571   {CC"concurrentGCRunToIdle0",    CC"()V",            (void*)&WB_ConcurrentGCRunToIdle},
2572   {CC"concurrentGCRunTo0",        CC"(Ljava/lang/String;)Z",
2573                                                       (void*)&WB_ConcurrentGCRunTo},
2574   {CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
2575                                                       (void*)&WB_CheckLibSpecifiesNoexecstack},
2576   {CC"isContainerized",           CC"()Z",            (void*)&WB_IsContainerized },
2577   {CC"validateCgroup",
2578       CC"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I",
2579                                                       (void*)&WB_ValidateCgroup },
2580   {CC"printOsInfo",               CC"()V",            (void*)&WB_PrintOsInfo },
2581   {CC"disableElfSectionCache",    CC"()V",            (void*)&WB_DisableElfSectionCache },
2582   {CC"resolvedMethodItemsCount",  CC"()J",            (void*)&WB_ResolvedMethodItemsCount },
2583   {CC"protectionDomainRemovedCount",   CC"()I",       (void*)&WB_ProtectionDomainRemovedCount },
2584   {CC"aotLibrariesCount", CC"()I",                    (void*)&WB_AotLibrariesCount },
2585   {CC"getKlassMetadataSize", CC"(Ljava/lang/Class;)I",(void*)&WB_GetKlassMetadataSize},
2586 
2587   {CC"createMetaspaceTestContext", CC"(JJ)J",         (void*)&WB_CreateMetaspaceTestContext},
2588   {CC"destroyMetaspaceTestContext", CC"(J)V",         (void*)&WB_DestroyMetaspaceTestContext},
2589   {CC"purgeMetaspaceTestContext", CC"(J)V",           (void*)&WB_PurgeMetaspaceTestContext},
2590   {CC"printMetaspaceTestContext", CC"(J)V",           (void*)&WB_PrintMetaspaceTestContext},
2591   {CC"getTotalCommittedWordsInMetaspaceTestContext", CC"(J)J",(void*)&WB_GetTotalCommittedWordsInMetaspaceTestContext},
2592   {CC"getTotalUsedWordsInMetaspaceTestContext", CC"(J)J", (void*)&WB_GetTotalUsedWordsInMetaspaceTestContext},
2593   {CC"createArenaInTestContext", CC"(JZ)J",           (void*)&WB_CreateArenaInTestContext},
2594   {CC"destroyMetaspaceTestArena", CC"(J)V",           (void*)&WB_DestroyMetaspaceTestArena},
2595   {CC"allocateFromMetaspaceTestArena", CC"(JJ)J",     (void*)&WB_AllocateFromMetaspaceTestArena},
2596   {CC"deallocateToMetaspaceTestArena", CC"(JJJ)V",    (void*)&WB_DeallocateToMetaspaceTestArena},
2597   {CC"maxMetaspaceAllocationSize", CC"()J",           (void*)&WB_GetMaxMetaspaceAllocationSize},
2598 
2599 };
2600 
2601 
2602 #undef CC
2603 
2604 JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
2605   {
2606     if (WhiteBoxAPI) {
2607       // Make sure that wbclass is loaded by the null classloader
2608       InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(wbclass)));
2609       Handle loader(THREAD, ik->class_loader());
2610       if (loader.is_null()) {
2611         WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
2612         WhiteBox::set_used();
2613       }
2614     }
2615   }
2616 JVM_END
< prev index next >