< prev index next >

src/hotspot/share/prims/whitebox.cpp

Print this page

  35 #include "classfile/javaClasses.inline.hpp"
  36 #include "classfile/modules.hpp"
  37 #include "classfile/stringTable.hpp"
  38 #include "classfile/symbolTable.hpp"
  39 #include "classfile/systemDictionary.hpp"
  40 #include "classfile/vmSymbols.hpp"
  41 #include "code/codeCache.hpp"
  42 #include "compiler/compilationPolicy.hpp"
  43 #include "compiler/compilerOracle.hpp"
  44 #include "compiler/directivesParser.hpp"
  45 #include "compiler/methodMatcher.hpp"
  46 #include "gc/shared/concurrentGCBreakpoints.hpp"
  47 #include "gc/shared/gcConfig.hpp"
  48 #include "gc/shared/genArguments.hpp"
  49 #include "jvm.h"
  50 #include "jvmtifiles/jvmtiEnv.hpp"
  51 #include "logging/log.hpp"
  52 #include "memory/iterator.hpp"
  53 #include "memory/memoryReserver.hpp"
  54 #include "memory/metadataFactory.hpp"

  55 #include "memory/metaspace/testHelpers.hpp"
  56 #include "memory/metaspaceUtils.hpp"
  57 #include "memory/oopFactory.hpp"
  58 #include "memory/resourceArea.hpp"
  59 #include "memory/universe.hpp"
  60 #include "nmt/mallocSiteTable.hpp"

  61 #include "oops/array.hpp"
  62 #include "oops/compressedOops.hpp"

  63 #include "oops/constantPool.inline.hpp"
  64 #include "oops/klass.inline.hpp"
  65 #include "oops/method.inline.hpp"
  66 #include "oops/methodData.inline.hpp"
  67 #include "oops/objArrayKlass.hpp"
  68 #include "oops/objArrayOop.inline.hpp"
  69 #include "oops/oop.inline.hpp"

  70 #include "oops/typeArrayOop.inline.hpp"
  71 #include "prims/jvmtiEnvBase.hpp"
  72 #include "prims/resolvedMethodTable.hpp"
  73 #include "prims/wbtestmethods/parserTests.hpp"
  74 #include "prims/whitebox.inline.hpp"
  75 #include "runtime/arguments.hpp"
  76 #include "runtime/atomic.hpp"
  77 #include "runtime/deoptimization.hpp"
  78 #include "runtime/fieldDescriptor.inline.hpp"
  79 #include "runtime/flags/jvmFlag.hpp"
  80 #include "runtime/flags/jvmFlagAccess.hpp"
  81 #include "runtime/frame.inline.hpp"
  82 #include "runtime/handles.inline.hpp"
  83 #include "runtime/handshake.hpp"
  84 #include "runtime/interfaceSupport.inline.hpp"
  85 #include "runtime/javaCalls.hpp"
  86 #include "runtime/javaThread.inline.hpp"
  87 #include "runtime/jniHandles.inline.hpp"

  88 #include "runtime/lockStack.hpp"
  89 #include "runtime/os.hpp"
  90 #include "runtime/stackFrameStream.inline.hpp"
  91 #include "runtime/synchronizer.hpp"
  92 #include "runtime/threadSMR.hpp"
  93 #include "runtime/vframe.hpp"
  94 #include "runtime/vm_version.hpp"
  95 #include "services/memoryService.hpp"
  96 #include "utilities/align.hpp"
  97 #include "utilities/checkedCast.hpp"
  98 #include "utilities/debug.hpp"
  99 #include "utilities/elfFile.hpp"
 100 #include "utilities/exceptions.hpp"
 101 #include "utilities/macros.hpp"
 102 #include "utilities/nativeCallStack.hpp"
 103 #include "utilities/ostream.hpp"
 104 #if INCLUDE_G1GC
 105 #include "gc/g1/g1Arguments.hpp"
 106 #include "gc/g1/g1CollectedHeap.inline.hpp"
 107 #include "gc/g1/g1ConcurrentMark.hpp"

1930   VMThread::execute(&force_safepoint_op);
1931 WB_END
1932 
1933 WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb))
1934   nullStream dev_null;
1935   ClassLoaderStatsVMOperation force_op(&dev_null);
1936   VMThread::execute(&force_op);
1937 WB_END
1938 
1939 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1940   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1941   return (jlong) ik->constants();
1942 WB_END
1943 
1944 WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass))
1945   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1946   objArrayOop resolved_refs= ik->constants()->resolved_references();
1947   return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs);
1948 WB_END
1949 







































































































1950 WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
1951   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1952   ConstantPool* cp = ik->constants();
1953   if (cp->cache() == nullptr) {
1954     return -1;
1955   }
1956   return cp->resolved_field_entries_length();
1957 WB_END
1958 
1959 WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
1960   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1961   ConstantPool* cp = ik->constants();
1962   if (cp->cache() == nullptr) {
1963       return -1;
1964   }
1965   return cp->resolved_field_entry_at(index)->constant_pool_index();
1966 WB_END
1967 
1968 WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
1969   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));

2893   {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
2894   {CC"DefineModule",       CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
2895                                                       (void*)&WB_DefineModule },
2896   {CC"AddModuleExports",   CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
2897                                                       (void*)&WB_AddModuleExports },
2898   {CC"AddReadsModule",     CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
2899                                                       (void*)&WB_AddReadsModule },
2900   {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2901                                                       (void*)&WB_AddModuleExportsToAllUnnamed },
2902   {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
2903                                                       (void*)&WB_AddModuleExportsToAll },
2904   {CC"deflateIdleMonitors", CC"()Z",                  (void*)&WB_DeflateIdleMonitors },
2905   {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated  },
2906   {CC"getInUseMonitorCount", CC"()J", (void*)&WB_getInUseMonitorCount  },
2907   {CC"getLockStackCapacity", CC"()I",                 (void*)&WB_getLockStackCapacity },
2908   {CC"supportsRecursiveLightweightLocking", CC"()Z",  (void*)&WB_supportsRecursiveLightweightLocking },
2909   {CC"forceSafepoint",     CC"()V",                   (void*)&WB_ForceSafepoint     },
2910   {CC"forceClassLoaderStatsSafepoint", CC"()V",       (void*)&WB_ForceClassLoaderStatsSafepoint },
2911   {CC"getConstantPool0",   CC"(Ljava/lang/Class;)J",  (void*)&WB_GetConstantPool    },
2912   {CC"getResolvedReferences0", CC"(Ljava/lang/Class;)[Ljava/lang/Object;", (void*)&WB_GetResolvedReferences},






2913   {CC"getFieldEntriesLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getFieldEntriesLength},
2914   {CC"getFieldCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getFieldCPIndex},
2915   {CC"getMethodEntriesLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getMethodEntriesLength},
2916   {CC"getMethodCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getMethodCPIndex},
2917   {CC"getIndyInfoLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getIndyInfoLength},
2918   {CC"getIndyCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getIndyCPIndex},
2919   {CC"printClasses0",      CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printClasses},
2920   {CC"printMethods0",      CC"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printMethods},
2921   {CC"getMethodBooleanOption",
2922       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
2923                                                       (void*)&WB_GetMethodBooleaneOption},
2924   {CC"getMethodIntxOption",
2925       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2926                                                       (void*)&WB_GetMethodIntxOption},
2927   {CC"getMethodUintxOption",
2928       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
2929                                                       (void*)&WB_GetMethodUintxOption},
2930   {CC"getMethodDoubleOption",
2931       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
2932                                                       (void*)&WB_GetMethodDoubleOption},

  35 #include "classfile/javaClasses.inline.hpp"
  36 #include "classfile/modules.hpp"
  37 #include "classfile/stringTable.hpp"
  38 #include "classfile/symbolTable.hpp"
  39 #include "classfile/systemDictionary.hpp"
  40 #include "classfile/vmSymbols.hpp"
  41 #include "code/codeCache.hpp"
  42 #include "compiler/compilationPolicy.hpp"
  43 #include "compiler/compilerOracle.hpp"
  44 #include "compiler/directivesParser.hpp"
  45 #include "compiler/methodMatcher.hpp"
  46 #include "gc/shared/concurrentGCBreakpoints.hpp"
  47 #include "gc/shared/gcConfig.hpp"
  48 #include "gc/shared/genArguments.hpp"
  49 #include "jvm.h"
  50 #include "jvmtifiles/jvmtiEnv.hpp"
  51 #include "logging/log.hpp"
  52 #include "memory/iterator.hpp"
  53 #include "memory/memoryReserver.hpp"
  54 #include "memory/metadataFactory.hpp"
  55 #include "memory/iterator.inline.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 "oops/access.hpp"
  63 #include "oops/array.hpp"
  64 #include "oops/compressedOops.hpp"
  65 #include "oops/compressedOops.inline.hpp"
  66 #include "oops/constantPool.inline.hpp"
  67 #include "oops/klass.inline.hpp"
  68 #include "oops/method.inline.hpp"
  69 #include "oops/methodData.inline.hpp"
  70 #include "oops/objArrayKlass.hpp"
  71 #include "oops/objArrayOop.inline.hpp"
  72 #include "oops/oop.inline.hpp"
  73 #include "oops/objArrayOop.inline.hpp"
  74 #include "oops/typeArrayOop.inline.hpp"
  75 #include "prims/jvmtiEnvBase.hpp"
  76 #include "prims/resolvedMethodTable.hpp"
  77 #include "prims/wbtestmethods/parserTests.hpp"
  78 #include "prims/whitebox.inline.hpp"
  79 #include "runtime/arguments.hpp"
  80 #include "runtime/atomic.hpp"
  81 #include "runtime/deoptimization.hpp"
  82 #include "runtime/fieldDescriptor.inline.hpp"
  83 #include "runtime/flags/jvmFlag.hpp"
  84 #include "runtime/flags/jvmFlagAccess.hpp"
  85 #include "runtime/frame.inline.hpp"
  86 #include "runtime/handles.inline.hpp"
  87 #include "runtime/handshake.hpp"
  88 #include "runtime/interfaceSupport.inline.hpp"
  89 #include "runtime/javaCalls.hpp"
  90 #include "runtime/javaThread.inline.hpp"
  91 #include "runtime/jniHandles.inline.hpp"
  92 #include "runtime/keepStackGCProcessed.hpp"
  93 #include "runtime/lockStack.hpp"
  94 #include "runtime/os.hpp"
  95 #include "runtime/stackFrameStream.inline.hpp"
  96 #include "runtime/synchronizer.hpp"
  97 #include "runtime/threadSMR.hpp"
  98 #include "runtime/vframe.hpp"
  99 #include "runtime/vm_version.hpp"
 100 #include "services/memoryService.hpp"
 101 #include "utilities/align.hpp"
 102 #include "utilities/checkedCast.hpp"
 103 #include "utilities/debug.hpp"
 104 #include "utilities/elfFile.hpp"
 105 #include "utilities/exceptions.hpp"
 106 #include "utilities/macros.hpp"
 107 #include "utilities/nativeCallStack.hpp"
 108 #include "utilities/ostream.hpp"
 109 #if INCLUDE_G1GC
 110 #include "gc/g1/g1Arguments.hpp"
 111 #include "gc/g1/g1CollectedHeap.inline.hpp"
 112 #include "gc/g1/g1ConcurrentMark.hpp"

1935   VMThread::execute(&force_safepoint_op);
1936 WB_END
1937 
1938 WB_ENTRY(void, WB_ForceClassLoaderStatsSafepoint(JNIEnv* env, jobject wb))
1939   nullStream dev_null;
1940   ClassLoaderStatsVMOperation force_op(&dev_null);
1941   VMThread::execute(&force_op);
1942 WB_END
1943 
1944 WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
1945   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1946   return (jlong) ik->constants();
1947 WB_END
1948 
1949 WB_ENTRY(jobjectArray, WB_GetResolvedReferences(JNIEnv* env, jobject wb, jclass klass))
1950   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
1951   objArrayOop resolved_refs= ik->constants()->resolved_references();
1952   return (jobjectArray)JNIHandles::make_local(THREAD, resolved_refs);
1953 WB_END
1954 
1955 WB_ENTRY(jobjectArray, WB_getObjectsViaKlassOopMaps(JNIEnv* env, jobject wb, jobject thing))
1956   oop aoop = JNIHandles::resolve(thing);
1957   if (!aoop->is_instance()) {
1958     return nullptr;
1959   }
1960   instanceHandle ih(THREAD, (instanceOop) aoop);
1961   InstanceKlass* klass = InstanceKlass::cast(ih->klass());
1962   if (klass->nonstatic_oop_map_count() == 0) {
1963     return nullptr;
1964   }
1965   const OopMapBlock* map = klass->start_of_nonstatic_oop_maps();
1966   const OopMapBlock* const end = map + klass->nonstatic_oop_map_count();
1967   int oop_count = 0;
1968   while (map < end) {
1969     oop_count += map->count();
1970     map++;
1971   }
1972 
1973   objArrayHandle result_array =
1974       oopFactory::new_objArray_handle(vmClasses::Object_klass(), oop_count, CHECK_NULL);
1975   map = klass->start_of_nonstatic_oop_maps();
1976   int index = 0;
1977   while (map < end) {
1978     int offset = map->offset();
1979     for (unsigned int j = 0; j < map->count(); j++) {
1980       result_array->obj_at_put(index++, ih->obj_field(offset));
1981       offset += heapOopSize;
1982     }
1983     map++;
1984   }
1985   return (jobjectArray)JNIHandles::make_local(THREAD, result_array());
1986 WB_END
1987 
1988 // Collect Object oops but not value objects...loaded from heap
1989 class CollectObjectOops : public BasicOopIterateClosure {
1990   public:
1991   GrowableArray<Handle>* _array;
1992 
1993   CollectObjectOops() {
1994       _array = new GrowableArray<Handle>(128);
1995   }
1996 
1997   void add_oop(oop o) {
1998     Handle oh = Handle(Thread::current(), o);
1999     if (oh != nullptr && oh->is_inline_type()) {
2000       oh->oop_iterate(this);
2001     } else {
2002       _array->append(oh);
2003     }
2004   }
2005 
2006   template <class T> inline void add_oop(T* p) { add_oop(HeapAccess<>::oop_load(p)); }
2007   void do_oop(oop* o) { add_oop(o); }
2008   void do_oop(narrowOop* v) { add_oop(v); }
2009 
2010   jobjectArray create_jni_result(JNIEnv* env, TRAPS) {
2011     objArrayHandle result_array =
2012         oopFactory::new_objArray_handle(vmClasses::Object_klass(), _array->length(), CHECK_NULL);
2013     for (int i = 0 ; i < _array->length(); i++) {
2014       result_array->obj_at_put(i, _array->at(i)());
2015     }
2016     return (jobjectArray)JNIHandles::make_local(THREAD, result_array());
2017   }
2018 };
2019 
2020 // Collect Object oops but not value objects...loaded from frames
2021 class CollectFrameObjectOops : public BasicOopIterateClosure {
2022  public:
2023   CollectObjectOops _collect;
2024 
2025   template <class T> inline void add_oop(T* p) { _collect.add_oop(RawAccess<>::oop_load(p)); }
2026   void do_oop(oop* o) { add_oop(o); }
2027   void do_oop(narrowOop* v) { add_oop(v); }
2028 
2029   jobjectArray create_jni_result(JNIEnv* env, TRAPS) {
2030     return _collect.create_jni_result(env, THREAD);
2031   }
2032 };
2033 
2034 // Collect Object oops for the given oop, iterate through value objects
2035 WB_ENTRY(jobjectArray, WB_getObjectsViaOopIterator(JNIEnv* env, jobject wb, jobject thing))
2036   ResourceMark rm(thread);
2037   Handle objh(thread, JNIHandles::resolve(thing));
2038   CollectObjectOops collectOops;
2039   objh->oop_iterate(&collectOops);
2040   return collectOops.create_jni_result(env, THREAD);
2041 WB_END
2042 
2043 // Collect Object oops for the given frame deep, iterate through value objects
2044 WB_ENTRY(jobjectArray, WB_getObjectsViaFrameOopIterator(JNIEnv* env, jobject wb, jint depth))
2045   KeepStackGCProcessedMark ksgcpm(THREAD);
2046   ResourceMark rm(THREAD);
2047   CollectFrameObjectOops collectOops;
2048   StackFrameStream sfs(thread, true /* update */, true /* process_frames */);
2049   while (depth > 0) { // Skip the native WB API frame
2050     sfs.next();
2051     frame* f = sfs.current();
2052     f->oops_do(&collectOops, nullptr, sfs.register_map());
2053     depth--;
2054   }
2055   return collectOops.create_jni_result(env, THREAD);
2056 WB_END
2057 
2058 WB_ENTRY(jint, WB_getFieldEntriesLength(JNIEnv* env, jobject wb, jclass klass))
2059   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2060   ConstantPool* cp = ik->constants();
2061   if (cp->cache() == nullptr) {
2062     return -1;
2063   }
2064   return cp->resolved_field_entries_length();
2065 WB_END
2066 
2067 WB_ENTRY(jint, WB_getFieldCPIndex(JNIEnv* env, jobject wb, jclass klass, jint index))
2068   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
2069   ConstantPool* cp = ik->constants();
2070   if (cp->cache() == nullptr) {
2071       return -1;
2072   }
2073   return cp->resolved_field_entry_at(index)->constant_pool_index();
2074 WB_END
2075 
2076 WB_ENTRY(jint, WB_getMethodEntriesLength(JNIEnv* env, jobject wb, jclass klass))
2077   InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));

3001   {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
3002   {CC"DefineModule",       CC"(Ljava/lang/Object;ZLjava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V",
3003                                                       (void*)&WB_DefineModule },
3004   {CC"AddModuleExports",   CC"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V",
3005                                                       (void*)&WB_AddModuleExports },
3006   {CC"AddReadsModule",     CC"(Ljava/lang/Object;Ljava/lang/Object;)V",
3007                                                       (void*)&WB_AddReadsModule },
3008   {CC"AddModuleExportsToAllUnnamed", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
3009                                                       (void*)&WB_AddModuleExportsToAllUnnamed },
3010   {CC"AddModuleExportsToAll", CC"(Ljava/lang/Object;Ljava/lang/String;)V",
3011                                                       (void*)&WB_AddModuleExportsToAll },
3012   {CC"deflateIdleMonitors", CC"()Z",                  (void*)&WB_DeflateIdleMonitors },
3013   {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated  },
3014   {CC"getInUseMonitorCount", CC"()J", (void*)&WB_getInUseMonitorCount  },
3015   {CC"getLockStackCapacity", CC"()I",                 (void*)&WB_getLockStackCapacity },
3016   {CC"supportsRecursiveLightweightLocking", CC"()Z",  (void*)&WB_supportsRecursiveLightweightLocking },
3017   {CC"forceSafepoint",     CC"()V",                   (void*)&WB_ForceSafepoint     },
3018   {CC"forceClassLoaderStatsSafepoint", CC"()V",       (void*)&WB_ForceClassLoaderStatsSafepoint },
3019   {CC"getConstantPool0",   CC"(Ljava/lang/Class;)J",  (void*)&WB_GetConstantPool    },
3020   {CC"getResolvedReferences0", CC"(Ljava/lang/Class;)[Ljava/lang/Object;", (void*)&WB_GetResolvedReferences},
3021   {CC"getObjectsViaKlassOopMaps0",
3022       CC"(Ljava/lang/Object;)[Ljava/lang/Object;",    (void*)&WB_getObjectsViaKlassOopMaps},
3023   {CC"getObjectsViaOopIterator0",
3024           CC"(Ljava/lang/Object;)[Ljava/lang/Object;",(void*)&WB_getObjectsViaOopIterator},
3025   {CC"getObjectsViaFrameOopIterator",
3026       CC"(I)[Ljava/lang/Object;",                     (void*)&WB_getObjectsViaFrameOopIterator},
3027   {CC"getFieldEntriesLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getFieldEntriesLength},
3028   {CC"getFieldCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getFieldCPIndex},
3029   {CC"getMethodEntriesLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getMethodEntriesLength},
3030   {CC"getMethodCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getMethodCPIndex},
3031   {CC"getIndyInfoLength0", CC"(Ljava/lang/Class;)I",  (void*)&WB_getIndyInfoLength},
3032   {CC"getIndyCPIndex0",    CC"(Ljava/lang/Class;I)I", (void*)&WB_getIndyCPIndex},
3033   {CC"printClasses0",      CC"(Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printClasses},
3034   {CC"printMethods0",      CC"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;", (void*)&WB_printMethods},
3035   {CC"getMethodBooleanOption",
3036       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Boolean;",
3037                                                       (void*)&WB_GetMethodBooleaneOption},
3038   {CC"getMethodIntxOption",
3039       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
3040                                                       (void*)&WB_GetMethodIntxOption},
3041   {CC"getMethodUintxOption",
3042       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Long;",
3043                                                       (void*)&WB_GetMethodUintxOption},
3044   {CC"getMethodDoubleOption",
3045       CC"(Ljava/lang/reflect/Executable;Ljava/lang/String;)Ljava/lang/Double;",
3046                                                       (void*)&WB_GetMethodDoubleOption},
< prev index next >