5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "cds.h"
27 #include "cds/archiveHeapLoader.hpp"
28 #include "cds/cdsConstants.hpp"
29 #include "cds/filemap.hpp"
30 #include "cds/heapShared.hpp"
31 #include "cds/metaspaceShared.hpp"
32 #include "classfile/classLoader.hpp"
33 #include "classfile/classLoaderDataGraph.hpp"
34 #include "classfile/classLoaderStats.hpp"
35 #include "classfile/classPrinter.hpp"
36 #include "classfile/javaClasses.inline.hpp"
37 #include "classfile/modules.hpp"
38 #include "classfile/protectionDomainCache.hpp"
39 #include "classfile/stringTable.hpp"
40 #include "classfile/symbolTable.hpp"
41 #include "classfile/systemDictionary.hpp"
42 #include "classfile/vmSymbols.hpp"
43 #include "code/codeCache.hpp"
44 #include "compiler/compilationPolicy.hpp"
45 #include "compiler/compilerOracle.hpp"
46 #include "compiler/directivesParser.hpp"
47 #include "compiler/methodMatcher.hpp"
48 #include "gc/shared/concurrentGCBreakpoints.hpp"
49 #include "gc/shared/gcConfig.hpp"
50 #include "gc/shared/gcLocker.inline.hpp"
51 #include "gc/shared/genArguments.hpp"
52 #include "jvmtifiles/jvmtiEnv.hpp"
53 #include "logging/log.hpp"
54 #include "memory/iterator.hpp"
55 #include "memory/metadataFactory.hpp"
56 #include "memory/metaspace/testHelpers.hpp"
57 #include "memory/metaspaceUtils.hpp"
58 #include "memory/oopFactory.hpp"
59 #include "memory/resourceArea.hpp"
60 #include "memory/universe.hpp"
61 #include "nmt/mallocSiteTable.hpp"
62 #include "nmt/memTracker.hpp"
63 #include "oops/array.hpp"
64 #include "oops/compressedOops.hpp"
65 #include "oops/constantPool.inline.hpp"
66 #include "oops/klass.inline.hpp"
67 #include "oops/method.inline.hpp"
68 #include "oops/methodData.inline.hpp"
69 #include "oops/objArrayKlass.hpp"
70 #include "oops/objArrayOop.inline.hpp"
71 #include "oops/oop.inline.hpp"
72 #include "oops/typeArrayOop.inline.hpp"
73 #include "prims/jvmtiEnvBase.hpp"
74 #include "prims/resolvedMethodTable.hpp"
75 #include "prims/wbtestmethods/parserTests.hpp"
76 #include "prims/whitebox.inline.hpp"
77 #include "runtime/arguments.hpp"
78 #include "runtime/atomic.hpp"
79 #include "runtime/deoptimization.hpp"
80 #include "runtime/fieldDescriptor.inline.hpp"
81 #include "runtime/flags/jvmFlag.hpp"
82 #include "runtime/flags/jvmFlagAccess.hpp"
83 #include "runtime/frame.inline.hpp"
84 #include "runtime/handles.inline.hpp"
85 #include "runtime/handshake.hpp"
86 #include "runtime/interfaceSupport.inline.hpp"
87 #include "runtime/javaCalls.hpp"
88 #include "runtime/javaThread.inline.hpp"
89 #include "runtime/jniHandles.inline.hpp"
90 #include "runtime/lockStack.hpp"
91 #include "runtime/os.hpp"
92 #include "runtime/stackFrameStream.inline.hpp"
93 #include "runtime/synchronizer.hpp"
94 #include "runtime/threadSMR.hpp"
95 #include "runtime/vframe.hpp"
96 #include "runtime/vm_version.hpp"
97 #include "services/memoryService.hpp"
98 #include "utilities/align.hpp"
99 #include "utilities/checkedCast.hpp"
100 #include "utilities/debug.hpp"
101 #include "utilities/elfFile.hpp"
102 #include "utilities/exceptions.hpp"
103 #include "utilities/macros.hpp"
104 #include "utilities/nativeCallStack.hpp"
105 #include "utilities/ostream.hpp"
106 #if INCLUDE_G1GC
107 #include "gc/g1/g1Arguments.hpp"
108 #include "gc/g1/g1CollectedHeap.inline.hpp"
109 #include "gc/g1/g1ConcurrentMark.hpp"
1885 VMThread::execute(&force_safepoint_op);
1886 WB_END
1887
1888 WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb))
1889 nullStream dev_null;
1890 ClassLoaderStatsVMOperation force_op(&dev_null);
1891 VMThread::execute(&force_op);
1892 WB_END
1893
1894 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1895 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1896 return (jlong) ik->constants();
1897 WB_END
1898
1899 WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass))
1900 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1901 objArrayOop resolved_refs= ik->constants()->resolved_references();
1902 return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs);
1903 WB_END
1904
1905 WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
1906 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1907 ConstantPool* cp = ik->constants();
1908 if (cp->cache() == nullptr) {
1909 return -1;
1910 }
1911 return cp->resolved_field_entries_length();
1912 WB_END
1913
1914 WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
1915 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1916 ConstantPool* cp = ik->constants();
1917 if (cp->cache() == nullptr) {
1918 return -1;
1919 }
1920 return cp->resolved_field_entry_at(index)->constant_pool_index();
1921 WB_END
1922
1923 WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
1924 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2858 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
2859 {CC"DefineModule", CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2860 (void*)&WB_DefineModule },
2861 {CC"AddModuleExports", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
2862 (void*)&WB_AddModuleExports },
2863 {CC"AddReadsModule", CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
2864 (void*)&WB_AddReadsModule },
2865 {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2866 (void*)&WB_AddModuleExportsToAllUnnamed },
2867 {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2868 (void*)&WB_AddModuleExportsToAll },
2869 {CC"deflateIdleMonitors", CC"()Z", (void*)&WB_DeflateIdleMonitors },
2870 {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
2871 {CC"getInUseMonitorCount", CC"()J", (void*)&WB_getInUseMonitorCount },
2872 {CC"getLockStackCapacity", CC"()I", (void*)&WB_getLockStackCapacity },
2873 {CC"supportsRecursiveLightweightLocking", CC"()Z", (void*)&WB_supportsRecursiveLightweightLocking },
2874 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
2875 {CC"forceClassLoaderStatsSafepoint", CC"()V", (void*)&WB_ForceClassLoaderStatsSafepoint },
2876 {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool },
2877 {CC"getResolvedReferences0", CC"(Ljava/lang/Class;)[Ljava/lang/Object;", (void*)&WB_GetResolvedReferences},
2878 {CC"getFieldEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getFieldEntriesLength},
2879 {CC"getFieldCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getFieldCPIndex},
2880 {CC"getMethodEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getMethodEntriesLength},
2881 {CC"getMethodCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getMethodCPIndex},
2882 {CC"getIndyInfoLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getIndyInfoLength},
2883 {CC"getIndyCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getIndyCPIndex},
2884 {CC"printClasses0", CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printClasses},
2885 {CC"printMethods0", CC"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printMethods},
2886 {CC"getMethodBooleanOption",
2887 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
2888 (void*)&WB_GetMethodBooleaneOption},
2889 {CC"getMethodIntxOption",
2890 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2891 (void*)&WB_GetMethodIntxOption},
2892 {CC"getMethodUintxOption",
2893 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2894 (void*)&WB_GetMethodUintxOption},
2895 {CC"getMethodDoubleOption",
2896 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
2897 (void*)&WB_GetMethodDoubleOption},
|
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "oops/access.hpp"
26 #include "precompiled.hpp"
27 #include "cds.h"
28 #include "cds/archiveHeapLoader.hpp"
29 #include "cds/cdsConstants.hpp"
30 #include "cds/filemap.hpp"
31 #include "cds/heapShared.hpp"
32 #include "cds/metaspaceShared.hpp"
33 #include "classfile/classLoader.hpp"
34 #include "classfile/classLoaderDataGraph.hpp"
35 #include "classfile/classLoaderStats.hpp"
36 #include "classfile/classPrinter.hpp"
37 #include "classfile/javaClasses.inline.hpp"
38 #include "classfile/modules.hpp"
39 #include "classfile/protectionDomainCache.hpp"
40 #include "classfile/stringTable.hpp"
41 #include "classfile/symbolTable.hpp"
42 #include "classfile/systemDictionary.hpp"
43 #include "classfile/vmSymbols.hpp"
44 #include "code/codeCache.hpp"
45 #include "compiler/compilationPolicy.hpp"
46 #include "compiler/compilerOracle.hpp"
47 #include "compiler/directivesParser.hpp"
48 #include "compiler/methodMatcher.hpp"
49 #include "gc/shared/concurrentGCBreakpoints.hpp"
50 #include "gc/shared/gcConfig.hpp"
51 #include "gc/shared/gcLocker.inline.hpp"
52 #include "gc/shared/genArguments.hpp"
53 #include "jvmtifiles/jvmtiEnv.hpp"
54 #include "logging/log.hpp"
55 #include "memory/iterator.hpp"
56 #include "memory/metadataFactory.hpp"
57 #include "memory/iterator.inline.hpp"
58 #include "memory/metaspace/testHelpers.hpp"
59 #include "memory/metaspaceUtils.hpp"
60 #include "memory/oopFactory.hpp"
61 #include "memory/resourceArea.hpp"
62 #include "memory/universe.hpp"
63 #include "nmt/mallocSiteTable.hpp"
64 #include "nmt/memTracker.hpp"
65 #include "oops/array.hpp"
66 #include "oops/compressedOops.hpp"
67 #include "oops/compressedOops.inline.hpp"
68 #include "oops/constantPool.inline.hpp"
69 #include "oops/klass.inline.hpp"
70 #include "oops/method.inline.hpp"
71 #include "oops/methodData.inline.hpp"
72 #include "oops/objArrayKlass.hpp"
73 #include "oops/objArrayOop.inline.hpp"
74 #include "oops/oop.inline.hpp"
75 #include "oops/objArrayOop.inline.hpp"
76 #include "oops/typeArrayOop.inline.hpp"
77 #include "prims/jvmtiEnvBase.hpp"
78 #include "prims/resolvedMethodTable.hpp"
79 #include "prims/wbtestmethods/parserTests.hpp"
80 #include "prims/whitebox.inline.hpp"
81 #include "runtime/arguments.hpp"
82 #include "runtime/atomic.hpp"
83 #include "runtime/deoptimization.hpp"
84 #include "runtime/fieldDescriptor.inline.hpp"
85 #include "runtime/flags/jvmFlag.hpp"
86 #include "runtime/flags/jvmFlagAccess.hpp"
87 #include "runtime/frame.inline.hpp"
88 #include "runtime/handles.inline.hpp"
89 #include "runtime/handshake.hpp"
90 #include "runtime/interfaceSupport.inline.hpp"
91 #include "runtime/javaCalls.hpp"
92 #include "runtime/javaThread.inline.hpp"
93 #include "runtime/jniHandles.inline.hpp"
94 #include "runtime/keepStackGCProcessed.hpp"
95 #include "runtime/lockStack.hpp"
96 #include "runtime/os.hpp"
97 #include "runtime/stackFrameStream.inline.hpp"
98 #include "runtime/synchronizer.hpp"
99 #include "runtime/threadSMR.hpp"
100 #include "runtime/vframe.hpp"
101 #include "runtime/vm_version.hpp"
102 #include "services/memoryService.hpp"
103 #include "utilities/align.hpp"
104 #include "utilities/checkedCast.hpp"
105 #include "utilities/debug.hpp"
106 #include "utilities/elfFile.hpp"
107 #include "utilities/exceptions.hpp"
108 #include "utilities/macros.hpp"
109 #include "utilities/nativeCallStack.hpp"
110 #include "utilities/ostream.hpp"
111 #if INCLUDE_G1GC
112 #include "gc/g1/g1Arguments.hpp"
113 #include "gc/g1/g1CollectedHeap.inline.hpp"
114 #include "gc/g1/g1ConcurrentMark.hpp"
1890 VMThread::execute(&force_safepoint_op);
1891 WB_END
1892
1893 WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb))
1894 nullStream dev_null;
1895 ClassLoaderStatsVMOperation force_op(&dev_null);
1896 VMThread::execute(&force_op);
1897 WB_END
1898
1899 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1900 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1901 return (jlong) ik->constants();
1902 WB_END
1903
1904 WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass))
1905 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1906 objArrayOop resolved_refs= ik->constants()->resolved_references();
1907 return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs);
1908 WB_END
1909
1910 WB_ENTRY(jobjectArray, WB_getObjectsViaKlassOopMaps(JNIEnv* env, jobject wb, jobject thing))
1911 oop aoop = JNIHandles::resolve(thing);
1912 if (!aoop->is_instance()) {
1913 return nullptr;
1914 }
1915 instanceHandle ih(THREAD, (instanceOop) aoop);
1916 InstanceKlass* klass = InstanceKlass::cast(ih->klass());
1917 if (klass->nonstatic_oop_map_count() == 0) {
1918 return nullptr;
1919 }
1920 const OopMapBlock* map = klass->start_of_nonstatic_oop_maps();
1921 const OopMapBlock* const end = map + klass->nonstatic_oop_map_count();
1922 int oop_count = 0;
1923 while (map < end) {
1924 oop_count += map->count();
1925 map++;
1926 }
1927
1928 objArrayHandle result_array =
1929 oopFactory::new_objArray_handle(vmClasses::Object_klass(), oop_count, CHECK_NULL);
1930 map = klass->start_of_nonstatic_oop_maps();
1931 int index = 0;
1932 while (map < end) {
1933 int offset = map->offset();
1934 for (unsigned int j = 0; j < map->count(); j++) {
1935 result_array->obj_at_put(index++, ih->obj_field(offset));
1936 offset += heapOopSize;
1937 }
1938 map++;
1939 }
1940 return (jobjectArray)JNIHandles::make_local(THREAD, result_array());
1941 WB_END
1942
1943 // Collect Object oops but not value objects...loaded from heap
1944 class CollectObjectOops : public BasicOopIterateClosure {
1945 public:
1946 GrowableArray<Handle>* _array;
1947
1948 CollectObjectOops() {
1949 _array = new GrowableArray<Handle>(128);
1950 }
1951
1952 void add_oop(oop o) {
1953 Handle oh = Handle(Thread::current(), o);
1954 if (oh != nullptr && oh->is_inline_type()) {
1955 oh->oop_iterate(this);
1956 } else {
1957 _array->append(oh);
1958 }
1959 }
1960
1961 template <class T> inline void add_oop(T* p) { add_oop(HeapAccess<>::oop_load(p)); }
1962 void do_oop(oop* o) { add_oop(o); }
1963 void do_oop(narrowOop* v) { add_oop(v); }
1964
1965 jobjectArray create_jni_result(JNIEnv* env, TRAPS) {
1966 objArrayHandle result_array =
1967 oopFactory::new_objArray_handle(vmClasses::Object_klass(), _array->length(), CHECK_NULL);
1968 for (int i = 0 ; i < _array->length(); i++) {
1969 result_array->obj_at_put(i, _array->at(i)());
1970 }
1971 return (jobjectArray)JNIHandles::make_local(THREAD, result_array());
1972 }
1973 };
1974
1975 // Collect Object oops but not value objects...loaded from frames
1976 class CollectFrameObjectOops : public BasicOopIterateClosure {
1977 public:
1978 CollectObjectOops _collect;
1979
1980 template <class T> inline void add_oop(T* p) { _collect.add_oop(RawAccess<>::oop_load(p)); }
1981 void do_oop(oop* o) { add_oop(o); }
1982 void do_oop(narrowOop* v) { add_oop(v); }
1983
1984 jobjectArray create_jni_result(JNIEnv* env, TRAPS) {
1985 return _collect.create_jni_result(env, THREAD);
1986 }
1987 };
1988
1989 // Collect Object oops for the given oop, iterate through value objects
1990 WB_ENTRY(jobjectArray, WB_getObjectsViaOopIterator(JNIEnv* env, jobject wb, jobject thing))
1991 ResourceMark rm(thread);
1992 Handle objh(thread, JNIHandles::resolve(thing));
1993 CollectObjectOops collectOops;
1994 objh->oop_iterate(&collectOops);
1995 return collectOops.create_jni_result(env, THREAD);
1996 WB_END
1997
1998 // Collect Object oops for the given frame deep, iterate through value objects
1999 WB_ENTRY(jobjectArray, WB_getObjectsViaFrameOopIterator(JNIEnv* env, jobject wb, jint depth))
2000 KeepStackGCProcessedMark ksgcpm(THREAD);
2001 ResourceMark rm(THREAD);
2002 CollectFrameObjectOops collectOops;
2003 StackFrameStream sfs(thread, true /* update */, true /* process_frames */);
2004 while (depth > 0) { // Skip the native WB API frame
2005 sfs.next();
2006 frame* f = sfs.current();
2007 f->oops_do(&collectOops, nullptr, sfs.register_map());
2008 depth--;
2009 }
2010 return collectOops.create_jni_result(env, THREAD);
2011 WB_END
2012
2013 WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
2014 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2015 ConstantPool* cp = ik->constants();
2016 if (cp->cache() == nullptr) {
2017 return -1;
2018 }
2019 return cp->resolved_field_entries_length();
2020 WB_END
2021
2022 WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
2023 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2024 ConstantPool* cp = ik->constants();
2025 if (cp->cache() == nullptr) {
2026 return -1;
2027 }
2028 return cp->resolved_field_entry_at(index)->constant_pool_index();
2029 WB_END
2030
2031 WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
2032 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2966 {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize },
2967 {CC"DefineModule", CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2968 (void*)&WB_DefineModule },
2969 {CC"AddModuleExports", CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
2970 (void*)&WB_AddModuleExports },
2971 {CC"AddReadsModule", CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
2972 (void*)&WB_AddReadsModule },
2973 {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2974 (void*)&WB_AddModuleExportsToAllUnnamed },
2975 {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2976 (void*)&WB_AddModuleExportsToAll },
2977 {CC"deflateIdleMonitors", CC"()Z", (void*)&WB_DeflateIdleMonitors },
2978 {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
2979 {CC"getInUseMonitorCount", CC"()J", (void*)&WB_getInUseMonitorCount },
2980 {CC"getLockStackCapacity", CC"()I", (void*)&WB_getLockStackCapacity },
2981 {CC"supportsRecursiveLightweightLocking", CC"()Z", (void*)&WB_supportsRecursiveLightweightLocking },
2982 {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
2983 {CC"forceClassLoaderStatsSafepoint", CC"()V", (void*)&WB_ForceClassLoaderStatsSafepoint },
2984 {CC"getConstantPool0", CC"(Ljava/lang/Class;)J", (void*)&WB_GetConstantPool },
2985 {CC"getResolvedReferences0", CC"(Ljava/lang/Class;)[Ljava/lang/Object;", (void*)&WB_GetResolvedReferences},
2986 {CC"getObjectsViaKlassOopMaps0",
2987 CC"(Ljava/lang/Object;)[Ljava/lang/Object;", (void*)&WB_getObjectsViaKlassOopMaps},
2988 {CC"getObjectsViaOopIterator0",
2989 CC"(Ljava/lang/Object;)[Ljava/lang/Object;",(void*)&WB_getObjectsViaOopIterator},
2990 {CC"getObjectsViaFrameOopIterator",
2991 CC"(I)[Ljava/lang/Object;", (void*)&WB_getObjectsViaFrameOopIterator},
2992 {CC"getFieldEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getFieldEntriesLength},
2993 {CC"getFieldCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getFieldCPIndex},
2994 {CC"getMethodEntriesLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getMethodEntriesLength},
2995 {CC"getMethodCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getMethodCPIndex},
2996 {CC"getIndyInfoLength0", CC"(Ljava/lang/Class;)I", (void*)&WB_getIndyInfoLength},
2997 {CC"getIndyCPIndex0", CC"(Ljava/lang/Class;I)I", (void*)&WB_getIndyCPIndex},
2998 {CC"printClasses0", CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printClasses},
2999 {CC"printMethods0", CC"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printMethods},
3000 {CC"getMethodBooleanOption",
3001 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
3002 (void*)&WB_GetMethodBooleaneOption},
3003 {CC"getMethodIntxOption",
3004 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
3005 (void*)&WB_GetMethodIntxOption},
3006 {CC"getMethodUintxOption",
3007 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
3008 (void*)&WB_GetMethodUintxOption},
3009 {CC"getMethodDoubleOption",
3010 CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
3011 (void*)&WB_GetMethodDoubleOption},
|