harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r488244 [4/5] - in /harmony/enhanced/classlib/trunk/modules/luni: ./ src/main/native/include/shared/
Date Mon, 18 Dec 2006 11:53:32 GMT
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jvmti.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jvmti.h?view=diff&rev=488244&r1=488243&r2=488244
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jvmti.h (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jvmti.h Mon Dec 18 03:53:30 2006
@@ -14,1103 +14,1405 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
+/** 
+ * @author Gregory Shimansky
+ * @version $Revision: 1.1.2.1.4.4 $
+ */  
+#ifndef _JVMTI_H_
+#define _JVMTI_H_
 
-#if !defined(jvmti_h)
-#define jvmti_h
+#include <stdlib.h>
 
 #include "jni.h"
-/* 
- *-----------------------------------------------------------------------------
- * JVMTI constants
- *-----------------------------------------------------------------------------
- */
-#define JVMTI_VERSION_1_0 0x30010000
-#define JVMTI_VERSION_1 (JVMTI_VERSION_1_0)
-#define JVMTI_VERSION (JVMTI_VERSION_1_0 + 37)  /* Spec version is 1.0.37 */
-#define JVMTI_CLASS_STATUS_VERIFIED   0x00000001
-#define JVMTI_CLASS_STATUS_PREPARED   0x00000002
-#define JVMTI_CLASS_STATUS_INITIALIZED    0x00000004
-#define JVMTI_CLASS_STATUS_ERROR    0x00000008
-#define JVMTI_CLASS_STATUS_ARRAY    0x00000010
-#define JVMTI_CLASS_STATUS_PRIMITIVE    0x00000020
-#define JVMTI_THREAD_MIN_PRIORITY   1
-#define JVMTI_THREAD_NORM_PRIORITY    5
-#define JVMTI_THREAD_MAX_PRIORITY   10
-#define JVMTI_THREAD_STATE_ALIVE      0x00000001
-#define JVMTI_THREAD_STATE_TERMINATED     0x00000002
-#define JVMTI_THREAD_STATE_RUNNABLE     0x00000004
-#define JVMTI_THREAD_STATE_WAITING_INDEFINITELY   0x00000010
-#define JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT   0x00000020
-#define JVMTI_THREAD_STATE_SLEEPING     0x00000040
-#define JVMTI_THREAD_STATE_WAITING      0x00000080
-#define JVMTI_THREAD_STATE_IN_OBJECT_WAIT   0x00000100
-#define JVMTI_THREAD_STATE_PARKED     0x00000200
-#define JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER 0x00000400
-#define JVMTI_THREAD_STATE_SUSPENDED      0x00100000
-#define JVMTI_THREAD_STATE_INTERRUPTED      0x00200000
-#define JVMTI_THREAD_STATE_IN_NATIVE      0x00400000
-#define JVMTI_THREAD_STATE_VENDOR_1     0x10000000
-#define JVMTI_THREAD_STATE_VENDOR_2     0x20000000
-#define JVMTI_THREAD_STATE_VENDOR_3     0x40000000
-#define JVMTI_JAVA_LANG_THREAD_STATE_MASK   \
-  JVMTI_THREAD_STATE_TERMINATED     \
-  | JVMTI_THREAD_STATE_ALIVE      \
-  | JVMTI_THREAD_STATE_RUNNABLE     \
-  | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER \
-  | JVMTI_THREAD_STATE_WAITING      \
-  | JVMTI_THREAD_STATE_WAITING_INDEFINITELY \
-  | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
-#define JVMTI_JAVA_LANG_THREAD_STATE_NEW    0
-#define JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED   \
-    JVMTI_THREAD_STATE_TERMINATED
-#define JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE   \
-    JVMTI_THREAD_STATE_ALIVE      \
-  | JVMTI_THREAD_STATE_RUNNABLE
-#define JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED    \
-    JVMTI_THREAD_STATE_ALIVE      \
-  | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER
-#define JVMTI_JAVA_LANG_THREAD_STATE_WAITING    \
-    JVMTI_THREAD_STATE_ALIVE      \
-  | JVMTI_THREAD_STATE_WAITING      \
-  | JVMTI_THREAD_STATE_WAITING_INDEFINITELY
-#define JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING  \
-    JVMTI_THREAD_STATE_ALIVE      \
-  | JVMTI_THREAD_STATE_WAITING      \
-  | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
-#define JVMTI_VERSION_INTERFACE_JNI   0x00000000
-#define JVMTI_VERSION_INTERFACE_JVMTI   0x30000000
-#define JVMTI_VERSION_MASK_INTERFACE_TYPE 0x70000000
-#define JVMTI_VERSION_MASK_MAJOR    0x0FFF0000
-#define JVMTI_VERSION_MASK_MINOR    0x0000FF00
-#define JVMTI_VERSION_MASK_MICRO    0x000000FF
-#define JVMTI_VERSION_SHIFT_MAJOR   16
-#define JVMTI_VERSION_SHIFT_MINOR   8
-#define JVMTI_VERSION_SHIFT_MICRO   0
+#include "jvmti_types.h"
 
 /*
- *-----------------------------------------------------------------------------
- * JVMTI enumerations
- *-----------------------------------------------------------------------------
+ * Supported JVMTI versions
  */
-typedef enum jvmtiEventMode
-{
-  JVMTI_ENABLE = 1,
-  JVMTI_DISABLE = 0,
-  jvmtiEventModeEnsureWideEnum = 0x1000000      /* ensure 4-byte enum */
-} jvmtiEventMode;
+#define JVMTI_VERSION_INTERFACE_JNI 0x00000000
+#define JVMTI_VERSION_INTERFACE_JVMTI 0x30000000
+#define JVMTI_VERSION_MASK_INTERFACE_TYPE 0x70000000
+#define JVMTI_VERSION_MASK_MAJOR 0x0FFF0000
+#define JVMTI_VERSION_MASK_MINOR 0x0000FF00
+#define JVMTI_VERSION_MASK_MICRO 0x000000FF
+#define JVMTI_VERSION_SHIFT_MAJOR 16
+#define JVMTI_VERSION_SHIFT_MINOR 8
+#define JVMTI_VERSION_SHIFT_MICRO 0
+
+#define JVMTI_VERSION_MAJOR 1
+#define JVMTI_VERSION_MINOR 0
+#define JVMTI_VERSION_MICRO 36
+
+#define JVMTI_VERSION_1_0 \
+    (JVMTI_VERSION_INTERFACE_JVMTI | \
+    (JVMTI_VERSION_MAJOR << JVMTI_VERSION_SHIFT_MAJOR) | \
+    (JVMTI_VERSION_MINOR << JVMTI_VERSION_SHIFT_MINOR) | \
+    (JVMTI_VERSION_MICRO << JVMTI_VERSION_SHIFT_MICRO))
+
+#define JVMTI_VERSION \
+    (JVMTI_VERSION_INTERFACE_JVMTI | \
+    (JVMTI_VERSION_MAJOR << JVMTI_VERSION_SHIFT_MAJOR) | \
+    (JVMTI_VERSION_MINOR << JVMTI_VERSION_SHIFT_MINOR) | \
+    (JVMTI_VERSION_MICRO << JVMTI_VERSION_SHIFT_MICRO))
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /**
+     * Agent Start-Up
+     * The library must export a start-up function with the following
+     * prototype:
+     */
+    JNIEXPORT jint JNICALL
+        Agent_OnLoad(JavaVM * vm, char *options, void *reserved);
+
+    /**
+     * Agent Shutdown
+     * The library may optionally export a shutdown function with the
+     * following prototype:
+     */
+    JNIEXPORT void JNICALL Agent_OnUnload(JavaVM * vm);
+
+#ifdef __cplusplus
+}               /* extern "C" { */
+#endif
 
-typedef enum jvmtiHeapObjectFilter
-{
-  JVMTI_HEAP_OBJECT_TAGGED = 1,
-  JVMTI_HEAP_OBJECT_UNTAGGED = 2,
-  JVMTI_HEAP_OBJECT_EITHER = 3,
-  jvmtiHeapObjectFilterEnsureWideEnum = 0x1000000       /* ensure 4-byte enum */
-} jvmtiHeapObjectFilter;
 
-typedef enum jvmtiHeapRootKind
+struct ti_interface
 {
-  JVMTI_HEAP_ROOT_JNI_GLOBAL = 1,
-  JVMTI_HEAP_ROOT_SYSTEM_CLASS = 2,
-  JVMTI_HEAP_ROOT_MONITOR = 3,
-  JVMTI_HEAP_ROOT_STACK_LOCAL = 4,
-  JVMTI_HEAP_ROOT_JNI_LOCAL = 5,
-  JVMTI_HEAP_ROOT_THREAD = 6,
-  JVMTI_HEAP_ROOT_OTHER = 7,
-  jvmtiHeapRootKindEnsureWideEnum = 0x1000000   /* ensure 4-byte enum */
-} jvmtiHeapRootKind;
+    void *reserved1;
 
-typedef enum jvmtiIterationControl
-{
-  JVMTI_ITERATION_CONTINUE = 1,
-  JVMTI_ITERATION_IGNORE = 2,
-  JVMTI_ITERATION_ABORT = 0,
-  jvmtiIterationControlEnsureWideEnum = 0x1000000       /* ensure 4-byte enum */
-} jvmtiIterationControl;
+    jvmtiError (JNICALL * SetEventNotificationMode) (jvmtiEnv * env,
+        jvmtiEventMode mode,
+        jvmtiEvent event_type,
+        jthread event_thread,
+        ...);
 
-typedef enum jvmtiJlocationFormat
-{
-  JVMTI_JLOCATION_JVMBCI = 1,
-  JVMTI_JLOCATION_MACHINEPC = 2,
-  JVMTI_JLOCATION_OTHER = 0,
-  jvmtiJlocationFormatEnsureWideEnum = 0x1000000        /* ensure 4-byte enum */
-} jvmtiJlocationFormat;
+    void *reserved3;
 
-typedef enum jvmtiObjectReferenceKind
-{
-  JVMTI_REFERENCE_CLASS = 1,
-  JVMTI_REFERENCE_FIELD = 2,
-  JVMTI_REFERENCE_ARRAY_ELEMENT = 3,
-  JVMTI_REFERENCE_CLASS_LOADER = 4,
-  JVMTI_REFERENCE_SIGNERS = 5,
-  JVMTI_REFERENCE_PROTECTION_DOMAIN = 6,
-  JVMTI_REFERENCE_INTERFACE = 7,
-  JVMTI_REFERENCE_STATIC_FIELD = 8,
-  JVMTI_REFERENCE_CONSTANT_POOL = 9,
-  jvmtiObjectReferenceKindEnsureWideEnum = 0x1000000    /* ensure 4-byte enum */
-} jvmtiObjectReferenceKind;
+    jvmtiError (JNICALL * GetAllThreads) (jvmtiEnv * env,
+        jint * threads_count_ptr,
+        jthread ** threads_ptr);
 
-typedef enum jvmtiParamKind
-{
-  JVMTI_KIND_IN = 91,
-  JVMTI_KIND_IN_PTR = 92,
-  JVMTI_KIND_IN_BUF = 93,
-  JVMTI_KIND_ALLOC_BUF = 94,
-  JVMTI_KIND_ALLOC_ALLOC_BUF = 95,
-  JVMTI_KIND_OUT = 96,
-  JVMTI_KIND_OUT_BUF = 97,
-  jvmtiParamKindEnsureWideEnum = 0x1000000      /* ensure 4-byte enum */
-} jvmtiParamKind;
+    jvmtiError (JNICALL * SuspendThread) (jvmtiEnv * env, jthread thread);
 
-typedef enum jvmtiParamTypes
-{
-  JVMTI_TYPE_JBYTE = 101,
-  JVMTI_TYPE_JCHAR = 102,
-  JVMTI_TYPE_JSHORT = 103,
-  JVMTI_TYPE_JINT = 104,
-  JVMTI_TYPE_JLONG = 105,
-  JVMTI_TYPE_JFLOAT = 106,
-  JVMTI_TYPE_JDOUBLE = 107,
-  JVMTI_TYPE_JBOOLEAN = 108,
-  JVMTI_TYPE_JOBJECT = 109,
-  JVMTI_TYPE_JTHREAD = 110,
-  JVMTI_TYPE_JCLASS = 111,
-  JVMTI_TYPE_JVALUE = 112,
-  JVMTI_TYPE_JFIELDID = 113,
-  JVMTI_TYPE_JMETHODID = 114,
-  JVMTI_TYPE_CCHAR = 115,
-  JVMTI_TYPE_CVOID = 116,
-  JVMTI_TYPE_JNIENV = 117,
-  jvmtiParamTypesEnsureWideEnum = 0x1000000     /* ensure 4-byte enum */
-} jvmtiParamTypes;
+    jvmtiError (JNICALL * ResumeThread) (jvmtiEnv * env, jthread thread);
 
-typedef enum jvmtiPhase
-{
-  JVMTI_PHASE_ONLOAD = 1,
-  JVMTI_PHASE_PRIMORDIAL = 2,
-  JVMTI_PHASE_LIVE = 4,
-  JVMTI_PHASE_START = 6,
-  JVMTI_PHASE_DEAD = 8,
-  jvmtiPhaseEnsureWideEnum = 0x1000000  /* ensure 4-byte enum */
-} jvmtiPhase;
+    jvmtiError (JNICALL * StopThread) (jvmtiEnv * env,
+        jthread thread, jobject exception);
 
-typedef enum jvmtiTimerKind
-{
-  JVMTI_TIMER_USER_CPU = 30,
-  JVMTI_TIMER_TOTAL_CPU = 31,
-  JVMTI_TIMER_ELAPSED = 32,
-  jvmtiTimerKindEnsureWideEnum = 0x1000000      /* ensure 4-byte enum */
-} jvmtiTimerKind;
+    jvmtiError (JNICALL * InterruptThread) (jvmtiEnv * env, jthread thread);
 
-typedef enum jvmtiVerboseFlag
-{
-  JVMTI_VERBOSE_OTHER = 0,
-  JVMTI_VERBOSE_GC = 1,
-  JVMTI_VERBOSE_CLASS = 2,
-  JVMTI_VERBOSE_JNI = 4,
-  jvmtiVerboseFlagEnsureWideEnum = 0x1000000    /* ensure 4-byte enum */
-} jvmtiVerboseFlag;
+    jvmtiError (JNICALL * GetThreadInfo) (jvmtiEnv * env,
+        jthread thread,
+        jvmtiThreadInfo * info_ptr);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI error codes
- *-----------------------------------------------------------------------------
- */
-typedef enum jvmtiError
-{
-  JVMTI_ERROR_NONE = 0,
-  JVMTI_ERROR_INVALID_THREAD = 10,
-  JVMTI_ERROR_INVALID_THREAD_GROUP = 11,
-  JVMTI_ERROR_INVALID_PRIORITY = 12,
-  JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13,
-  JVMTI_ERROR_THREAD_SUSPENDED = 14,
-  JVMTI_ERROR_THREAD_NOT_ALIVE = 15,
-  JVMTI_ERROR_INVALID_OBJECT = 20,
-  JVMTI_ERROR_INVALID_CLASS = 21,
-  JVMTI_ERROR_CLASS_NOT_PREPARED = 22,
-  JVMTI_ERROR_INVALID_METHODID = 23,
-  JVMTI_ERROR_INVALID_LOCATION = 24,
-  JVMTI_ERROR_INVALID_FIELDID = 25,
-  JVMTI_ERROR_NO_MORE_FRAMES = 31,
-  JVMTI_ERROR_OPAQUE_FRAME = 32,
-  JVMTI_ERROR_TYPE_MISMATCH = 34,
-  JVMTI_ERROR_INVALID_SLOT = 35,
-  JVMTI_ERROR_DUPLICATE = 40,
-  JVMTI_ERROR_NOT_FOUND = 41,
-  JVMTI_ERROR_INVALID_MONITOR = 50,
-  JVMTI_ERROR_NOT_MONITOR_OWNER = 51,
-  JVMTI_ERROR_INTERRUPT = 52,
-  JVMTI_ERROR_INVALID_CLASS_FORMAT = 60,
-  JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61,
-  JVMTI_ERROR_FAILS_VERIFICATION = 62,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64,
-  JVMTI_ERROR_INVALID_TYPESTATE = 65,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67,
-  JVMTI_ERROR_UNSUPPORTED_VERSION = 68,
-  JVMTI_ERROR_NAMES_DONT_MATCH = 69,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70,
-  JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71,
-  JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
-  JVMTI_ERROR_NOT_AVAILABLE = 98,
-  JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99,
-  JVMTI_ERROR_NULL_POINTER = 100,
-  JVMTI_ERROR_ABSENT_INFORMATION = 101,
-  JVMTI_ERROR_INVALID_EVENT_TYPE = 102,
-  JVMTI_ERROR_ILLEGAL_ARGUMENT = 103,
-  JVMTI_ERROR_NATIVE_METHOD = 104,
-  JVMTI_ERROR_OUT_OF_MEMORY = 110,
-  JVMTI_ERROR_ACCESS_DENIED = 111,
-  JVMTI_ERROR_WRONG_PHASE = 112,
-  JVMTI_ERROR_INTERNAL = 113,
-  JVMTI_ERROR_UNATTACHED_THREAD = 115,
-  JVMTI_ERROR_INVALID_ENVIRONMENT = 116,
-  jvmtiErrorEnsureWideEnum = 0x1000000  /* ensure 4-byte enum */
-} jvmtiError;
+    jvmtiError (JNICALL * GetOwnedMonitorInfo) (jvmtiEnv * env,
+        jthread thread,
+        jint *
+        owned_monitor_count_ptr,
+        jobject **
+        owned_monitors_ptr);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI base types
- *-----------------------------------------------------------------------------
- */
-typedef jobject jthread;
-typedef jobject jthreadGroup;
-typedef jlong jlocation;
-/* hidden type */
-struct _jrawMonitorID;
-typedef struct _jrawMonitorID *jrawMonitorID;
-typedef struct JNINativeInterface_ jniNativeInterface;
-struct JVMTINativeInterface_;
+    jvmtiError (JNICALL * GetCurrentContendedMonitor) (jvmtiEnv * env,
+        jthread thread,
+        jobject * monitor_ptr);
 
-struct _jvmtiEnv
-{
-  const struct JVMTINativeInterface_ *functions;
-};
+    jvmtiError (JNICALL * RunAgentThread) (jvmtiEnv * env,
+        jthread thread,
+        jvmtiStartFunction proc,
+        const void *arg, jint priority);
 
-typedef struct JVMTINativeInterface_ *jvmtiEnv;
+    jvmtiError (JNICALL * GetTopThreadGroups) (jvmtiEnv * env,
+        jint * group_count_ptr,
+        jthreadGroup ** groups_ptr);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI function types
- *-----------------------------------------------------------------------------
- */
-typedef void (JNICALL * jvmtiExtensionEvent) (jvmtiEnv * jvmti_env, ...);
-typedef jvmtiError (JNICALL * jvmtiExtensionFunction)
-  (jvmtiEnv * jvmti_env, ...);
-typedef jvmtiIterationControl (JNICALL * jvmtiHeapObjectCallback)
-  (jlong class_tag, jlong size, jlong * tag_ptr, void *user_data);
-typedef jvmtiIterationControl (JNICALL * jvmtiHeapRootCallback)
-  (jvmtiHeapRootKind root_kind,
-   jlong class_tag, jlong size, jlong * tag_ptr, void *user_data);
-typedef jvmtiIterationControl (JNICALL * jvmtiObjectReferenceCallback)
-  (jvmtiObjectReferenceKind reference_kind,
-   jlong class_tag, jlong size, jlong * tag_ptr,
-   jlong referrer_tag, jint referrer_index, void *user_data);
-typedef jvmtiIterationControl (JNICALL * jvmtiStackReferenceCallback)
-  (jvmtiHeapRootKind root_kind,
-   jlong class_tag, jlong size, jlong * tag_ptr,
-   jlong thread_tag, jint depth, jmethodID method, jint slot,
-   void *user_data);
-typedef void (JNICALL * jvmtiStartFunction)
-  (jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg);
+    jvmtiError (JNICALL * GetThreadGroupInfo) (jvmtiEnv * env,
+        jthreadGroup group,
+        jvmtiThreadGroupInfo *
+        info_ptr);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI structure types
- *-----------------------------------------------------------------------------
- */
-typedef struct jvmtiFrameInfo
-{
-  jmethodID method;
-  jlocation location;
-} jvmtiFrameInfo;
+    jvmtiError (JNICALL * GetThreadGroupChildren) (jvmtiEnv * env,
+        jthreadGroup group,
+        jint * thread_count_ptr,
+        jthread ** threads_ptr,
+        jint * group_count_ptr,
+        jthreadGroup **
+        groups_ptr);
+
+    jvmtiError (JNICALL * GetFrameCount) (jvmtiEnv * env,
+        jthread thread, jint * count_ptr);
+
+    jvmtiError (JNICALL * GetThreadState) (jvmtiEnv * env,
+        jthread thread,
+        jint * thread_state_ptr);
 
-typedef struct jvmtiStackInfo
-{
-  jthread thread;
-  jint state;
-  jvmtiFrameInfo *frame_buffer;
-  jint frame_count;
-} jvmtiStackInfo;
+    void *reserved18;
 
-typedef struct jvmtiAddrLocationMap
-{
-  const void *start_address;
-  jlocation location;
-} jvmtiAddrLocationMap;
+    jvmtiError (JNICALL * GetFrameLocation) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jmethodID * method_ptr,
+        jlocation * location_ptr);
+
+    jvmtiError (JNICALL * NotifyFramePop) (jvmtiEnv * env,
+        jthread thread, jint depth);
+
+    jvmtiError (JNICALL * GetLocalObject) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jobject * value_ptr);
+
+    jvmtiError (JNICALL * GetLocalInt) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jint * value_ptr);
+
+    jvmtiError (JNICALL * GetLocalLong) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jlong * value_ptr);
+
+    jvmtiError (JNICALL * GetLocalFloat) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jfloat * value_ptr);
+
+    jvmtiError (JNICALL * GetLocalDouble) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jdouble * value_ptr);
+
+    jvmtiError (JNICALL * SetLocalObject) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jobject value);
+
+    jvmtiError (JNICALL * SetLocalInt) (jvmtiEnv * env,
+        jthread thread,
+        jint depth, jint slot, jint value);
+
+    jvmtiError (JNICALL * SetLocalLong) (jvmtiEnv * env,
+        jthread thread,
+        jint depth, jint slot, jlong value);
+
+    jvmtiError (JNICALL * SetLocalFloat) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jfloat value);
+
+    jvmtiError (JNICALL * SetLocalDouble) (jvmtiEnv * env,
+        jthread thread,
+        jint depth,
+        jint slot, jdouble value);
+
+    jvmtiError (JNICALL * CreateRawMonitor) (jvmtiEnv * env,
+        const char *name,
+        jrawMonitorID * monitor_ptr);
 
-typedef struct
-{
-  unsigned int can_tag_objects:1;
-  unsigned int can_generate_field_modification_events:1;
-  unsigned int can_generate_field_access_events:1;
-  unsigned int can_get_bytecodes:1;
-  unsigned int can_get_synthetic_attribute:1;
-  unsigned int can_get_owned_monitor_info:1;
-  unsigned int can_get_current_contended_monitor:1;
-  unsigned int can_get_monitor_info:1;
-  unsigned int can_pop_frame:1;
-  unsigned int can_redefine_classes:1;
-  unsigned int can_signal_thread:1;
-  unsigned int can_get_source_file_name:1;
-  unsigned int can_get_line_numbers:1;
-  unsigned int can_get_source_debug_extension:1;
-  unsigned int can_access_local_variables:1;
-  unsigned int can_maintain_original_method_order:1;
-  unsigned int can_generate_single_step_events:1;
-  unsigned int can_generate_exception_events:1;
-  unsigned int can_generate_frame_pop_events:1;
-  unsigned int can_generate_breakpoint_events:1;
-  unsigned int can_suspend:1;
-  unsigned int can_redefine_any_class:1;
-  unsigned int can_get_current_thread_cpu_time:1;
-  unsigned int can_get_thread_cpu_time:1;
-  unsigned int can_generate_method_entry_events:1;
-  unsigned int can_generate_method_exit_events:1;
-  unsigned int can_generate_all_class_hook_events:1;
-  unsigned int can_generate_compiled_method_load_events:1;
-  unsigned int can_generate_monitor_events:1;
-  unsigned int can_generate_vm_object_alloc_events:1;
-  unsigned int can_generate_native_method_bind_events:1;
-  unsigned int can_generate_garbage_collection_events:1;
-  unsigned int can_generate_object_free_events:1;
-  unsigned int:15;
-  unsigned int:16;
-  unsigned int:16;
-  unsigned int:16;
-  unsigned int:16;
-  unsigned int:16;
-} jvmtiCapabilities;
+    jvmtiError (JNICALL * DestroyRawMonitor) (jvmtiEnv * env,
+        jrawMonitorID monitor);
 
-typedef struct jvmtiClassDefinition
-{
-  jclass klass;
-  jint class_byte_count;
-  const unsigned char *class_bytes;
-} jvmtiClassDefinition;
+    jvmtiError (JNICALL * RawMonitorEnter) (jvmtiEnv * env,
+        jrawMonitorID monitor);
 
-typedef struct jvmtiParamInfo
-{
-  char *name;
-  jvmtiParamKind kind;
-  jvmtiParamTypes base_type;
-  jboolean null_ok;
-} jvmtiParamInfo;
+    jvmtiError (JNICALL * RawMonitorExit) (jvmtiEnv * env,
+        jrawMonitorID monitor);
 
-typedef struct jvmtiExtensionEventInfo
-{
-  jint extension_event_index;
-  char *id;
-  char *short_description;
-  jint param_count;
-  jvmtiParamInfo *params;
-} jvmtiExtensionEventInfo;
+    jvmtiError (JNICALL * RawMonitorWait) (jvmtiEnv * env,
+        jrawMonitorID monitor,
+        jlong millis);
 
-typedef struct jvmtiExtensionFunctionInfo
-{
-  jvmtiExtensionFunction func;
-  char *id;
-  char *short_description;
-  jint param_count;
-  jvmtiParamInfo *params;
-  jint error_count;
-  jvmtiError *errors;
-} jvmtiExtensionFunctionInfo;
+    jvmtiError (JNICALL * RawMonitorNotify) (jvmtiEnv * env,
+        jrawMonitorID monitor);
 
-typedef struct jvmtiLineNumberEntry
-{
-  jlocation start_location;
-  jint line_number;
-} jvmtiLineNumberEntry;
+    jvmtiError (JNICALL * RawMonitorNotifyAll) (jvmtiEnv * env,
+        jrawMonitorID monitor);
 
-typedef struct jvmtiLocalVariableEntry
-{
-  jlocation start_location;
-  jint length;
-  char *name;
-  char *signature;
-  char *generic_signature;
-  jint slot;
-} jvmtiLocalVariableEntry;
+    jvmtiError (JNICALL * SetBreakpoint) (jvmtiEnv * env,
+        jmethodID method,
+        jlocation location);
+
+    jvmtiError (JNICALL * ClearBreakpoint) (jvmtiEnv * env,
+        jmethodID method,
+        jlocation location);
 
-typedef struct jvmtiMonitorUsage
-{
-  jthread owner;
-  jint entry_count;
-  jint waiter_count;
-  jthread *waiters;
-  jint notify_waiter_count;
-  jthread *notify_waiters;
-} jvmtiMonitorUsage;
+    void *reserved40;
 
-typedef struct jvmtiThreadGroupInfo
-{
-  jthreadGroup parent;
-  char *name;
-  jint max_priority;
-  jboolean is_daemon;
-} jvmtiThreadGroupInfo;
+    jvmtiError (JNICALL * SetFieldAccessWatch) (jvmtiEnv * env,
+        jclass clazz, jfieldID field);
 
-typedef struct jvmtiThreadInfo
-{
-  char *name;
-  jint priority;
-  jboolean is_daemon;
-  jthreadGroup thread_group;
-  jobject context_class_loader;
-} jvmtiThreadInfo;
+    jvmtiError (JNICALL * ClearFieldAccessWatch) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field);
 
-typedef struct jvmtiTimerInfo
-{
-  jlong max_value;
-  jboolean may_skip_forward;
-  jboolean may_skip_backward;
-  jvmtiTimerKind kind;
-  jlong reserved1;
-  jlong reserved2;
-} jvmtiTimerInfo;
+    jvmtiError (JNICALL * SetFieldModificationWatch) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI events
- *-----------------------------------------------------------------------------
- */
-typedef enum jvmtiEvent
-{
-  JVMTI_EVENT_VM_INIT = 50,
-  JVMTI_EVENT_VM_DEATH = 51,
-  JVMTI_EVENT_THREAD_START = 52,
-  JVMTI_EVENT_THREAD_END = 53,
-  JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54,
-  JVMTI_EVENT_CLASS_LOAD = 55,
-  JVMTI_EVENT_CLASS_PREPARE = 56,
-  JVMTI_EVENT_VM_START = 57,
-  JVMTI_EVENT_EXCEPTION = 58,
-  JVMTI_EVENT_EXCEPTION_CATCH = 59,
-  JVMTI_EVENT_SINGLE_STEP = 60,
-  JVMTI_EVENT_FRAME_POP = 61,
-  JVMTI_EVENT_BREAKPOINT = 62,
-  JVMTI_EVENT_FIELD_ACCESS = 63,
-  JVMTI_EVENT_FIELD_MODIFICATION = 64,
-  JVMTI_EVENT_METHOD_ENTRY = 65,
-  JVMTI_EVENT_METHOD_EXIT = 66,
-  JVMTI_EVENT_NATIVE_METHOD_BIND = 67,
-  JVMTI_EVENT_COMPILED_METHOD_LOAD = 68,
-  JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69,
-  JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70,
-  JVMTI_EVENT_DATA_DUMP_REQUEST = 71,
-  JVMTI_EVENT_MONITOR_WAIT = 73,
-  JVMTI_EVENT_MONITOR_WAITED = 74,
-  JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75,
-  JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76,
-  JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
-  JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
-  JVMTI_EVENT_OBJECT_FREE = 83,
-  JVMTI_EVENT_VM_OBJECT_ALLOC = 84,
-  jvmtiEventEnsureWideEnum = 0x1000000  /* ensure 4-byte enum */
-} jvmtiEvent;
+    jvmtiError (JNICALL * ClearFieldModificationWatch) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI callbacks
- *-----------------------------------------------------------------------------
- */
-typedef void (JNICALL * jvmtiEventSingleStep) (jvmtiEnv * jvmti_env,
-                                               JNIEnv * jni_env,
-                                               jthread thread,
-                                               jmethodID method,
-                                               jlocation location);
-typedef void (JNICALL * jvmtiEventBreakpoint) (jvmtiEnv * jvmti_env,
-                                               JNIEnv * jni_env,
-                                               jthread thread,
-                                               jmethodID method,
-                                               jlocation location);
-typedef void (JNICALL * jvmtiEventFieldAccess) (jvmtiEnv * jvmti_env,
-                                                JNIEnv * jni_env,
-                                                jthread thread,
-                                                jmethodID method,
-                                                jlocation location,
-                                                jclass field_klass,
-                                                jobject object,
-                                                jfieldID field);
-typedef void (JNICALL * jvmtiEventFieldModification) (jvmtiEnv * jvmti_env,
-                                                      JNIEnv * jni_env,
-                                                      jthread thread,
-                                                      jmethodID method,
-                                                      jlocation location,
-                                                      jclass field_klass,
-                                                      jobject object,
-                                                      jfieldID field,
-                                                      char signature_type,
-                                                      jvalue new_value);
-typedef void (JNICALL * jvmtiEventFramePop) (jvmtiEnv * jvmti_env,
-                                             JNIEnv * jni_env,
-                                             jthread thread,
-                                             jmethodID method,
-                                             jboolean
-                                             was_popped_by_exception);
-typedef void (JNICALL * jvmtiEventMethodEntry) (jvmtiEnv * jvmti_env,
-                                                JNIEnv * jni_env,
-                                                jthread thread,
-                                                jmethodID method);
-typedef void (JNICALL * jvmtiEventMethodExit) (jvmtiEnv * jvmti_env,
-                                               JNIEnv * jni_env,
-                                               jthread thread,
-                                               jmethodID method,
-                                               jboolean
-                                               was_popped_by_exception,
-                                               jvalue return_value);
-typedef void (JNICALL * jvmtiEventNativeMethodBind) (jvmtiEnv * jvmti_env,
-                                                     JNIEnv * jni_env,
-                                                     jthread thread,
-                                                     jmethodID method,
-                                                     void *address,
-                                                     void **new_address_ptr);
-typedef void (JNICALL * jvmtiEventException) (jvmtiEnv * jvmti_env,
-                                              JNIEnv * jni_env,
-                                              jthread thread,
-                                              jmethodID method,
-                                              jlocation location,
-                                              jobject exception,
-                                              jmethodID catch_method,
-                                              jlocation catch_location);
-typedef void (JNICALL * jvmtiEventExceptionCatch) (jvmtiEnv * jvmti_env,
-                                                   JNIEnv * jni_env,
-                                                   jthread thread,
-                                                   jmethodID method,
-                                                   jlocation location,
-                                                   jobject exception);
-typedef void (JNICALL * jvmtiEventThreadStart) (jvmtiEnv * jvmti_env,
-                                                JNIEnv * jni_env,
-                                                jthread thread);
-typedef void (JNICALL * jvmtiEventThreadEnd) (jvmtiEnv * jvmti_env,
-                                              JNIEnv * jni_env,
-                                              jthread thread);
-typedef void (JNICALL * jvmtiEventClassLoad) (jvmtiEnv * jvmti_env,
-                                              JNIEnv * jni_env,
-                                              jthread thread, jclass klass);
-typedef void (JNICALL * jvmtiEventClassPrepare) (jvmtiEnv * jvmti_env,
-                                                 JNIEnv * jni_env,
-                                                 jthread thread,
-                                                 jclass klass);
-typedef void (JNICALL * jvmtiEventClassFileLoadHook) (jvmtiEnv * jvmti_env,
-                                                      JNIEnv * jni_env,
-                                                      jclass
-                                                      class_being_redefined,
-                                                      jobject loader,
-                                                      const char *name,
-                                                      jobject
-                                                      protection_domain,
-                                                      jint class_data_len,
-                                                      const unsigned char
-                                                      *class_data,
-                                                      jint *
-                                                      new_class_data_len,
-                                                      unsigned char
-                                                      **new_class_data);
-typedef void (JNICALL * jvmtiEventVMStart) (jvmtiEnv * jvmti_env,
-                                            JNIEnv * jni_env);
-typedef void (JNICALL * jvmtiEventVMInit) (jvmtiEnv * jvmti_env,
-                                           JNIEnv * jni_env, jthread thread);
-typedef void (JNICALL * jvmtiEventVMDeath) (jvmtiEnv * jvmti_env,
-                                            JNIEnv * jni_env);
-typedef void (JNICALL * jvmtiEventCompiledMethodLoad) (jvmtiEnv * jvmti_env,
-                                                       jmethodID method,
-                                                       jint code_size,
-                                                       const void *code_addr,
-                                                       jint map_length,
-                                                       const
-                                                       jvmtiAddrLocationMap *
-                                                       map,
-                                                       const void
-                                                       *compile_info);
-typedef void (JNICALL * jvmtiEventCompiledMethodUnload) (jvmtiEnv * jvmti_env,
-                                                         jmethodID method,
-                                                         const void
-                                                         *code_addr);
-typedef void (JNICALL * jvmtiEventDynamicCodeGenerated) (jvmtiEnv * jvmti_env,
-                                                         const char *name,
-                                                         const void *address,
-                                                         jint length);
-typedef void (JNICALL * jvmtiEventDataDumpRequest) (jvmtiEnv * jvmti_env);
-typedef void (JNICALL * jvmtiEventMonitorContendedEnter) (jvmtiEnv *
-                                                          jvmti_env,
-                                                          JNIEnv * jni_env,
-                                                          jthread thread,
-                                                          jobject object);
-typedef void (JNICALL * jvmtiEventMonitorContendedEntered) (jvmtiEnv *
-                                                            jvmti_env,
-                                                            JNIEnv * jni_env,
-                                                            jthread thread,
-                                                            jobject object);
-typedef void (JNICALL * jvmtiEventMonitorWait) (jvmtiEnv * jvmti_env,
-                                                JNIEnv * jni_env,
-                                                jthread thread,
-                                                jobject object,
-                                                jlong timeout);
-typedef void (JNICALL * jvmtiEventMonitorWaited) (jvmtiEnv * jvmti_env,
-                                                  JNIEnv * jni_env,
-                                                  jthread thread,
-                                                  jobject object,
-                                                  jboolean timed_out);
-typedef void (JNICALL * jvmtiEventVMObjectAlloc) (jvmtiEnv * jvmti_env,
-                                                  JNIEnv * jni_env,
-                                                  jthread thread,
-                                                  jobject object,
-                                                  jclass object_klass,
-                                                  jlong size);
-typedef void (JNICALL * jvmtiEventObjectFree) (jvmtiEnv * jvmti_env,
-                                               jlong tag);
-typedef void (JNICALL * jvmtiEventGarbageCollectionStart) (jvmtiEnv *
-                                                           jvmti_env);
-typedef void (JNICALL * jvmtiEventGarbageCollectionFinish) (jvmtiEnv *
-                                                            jvmti_env);
-typedef void *jvmtiEventReserved;
+    void *reserved45;
 
-typedef struct
-{
-  jvmtiEventVMInit VMInit;
-  jvmtiEventVMDeath VMDeath;
-  jvmtiEventThreadStart ThreadStart;
-  jvmtiEventThreadEnd ThreadEnd;
-  jvmtiEventClassFileLoadHook ClassFileLoadHook;
-  jvmtiEventClassLoad ClassLoad;
-  jvmtiEventClassPrepare ClassPrepare;
-  jvmtiEventVMStart VMStart;
-  jvmtiEventException Exception;
-  jvmtiEventExceptionCatch ExceptionCatch;
-  jvmtiEventSingleStep SingleStep;
-  jvmtiEventFramePop FramePop;
-  jvmtiEventBreakpoint Breakpoint;
-  jvmtiEventFieldAccess FieldAccess;
-  jvmtiEventFieldModification FieldModification;
-  jvmtiEventMethodEntry MethodEntry;
-  jvmtiEventMethodExit MethodExit;
-  jvmtiEventNativeMethodBind NativeMethodBind;
-  jvmtiEventCompiledMethodLoad CompiledMethodLoad;
-  jvmtiEventCompiledMethodUnload CompiledMethodUnload;
-  jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
-  jvmtiEventDataDumpRequest DataDumpRequest;
-  jvmtiEventReserved reserved72;
-  jvmtiEventMonitorWait MonitorWait;
-  jvmtiEventMonitorWaited MonitorWaited;
-  jvmtiEventMonitorContendedEnter MonitorContendedEnter;
-  jvmtiEventMonitorContendedEntered MonitorContendedEntered;
-  jvmtiEventReserved reserved77;
-  jvmtiEventReserved reserved78;
-  jvmtiEventReserved reserved79;
-  jvmtiEventReserved reserved80;
-  jvmtiEventGarbageCollectionStart GarbageCollectionStart;
-  jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
-  jvmtiEventObjectFree ObjectFree;
-  jvmtiEventVMObjectAlloc VMObjectAlloc;
-} jvmtiEventCallbacks;
+    jvmtiError (JNICALL * Allocate) (jvmtiEnv * env,
+        jlong size, unsigned char **mem_ptr);
 
-/*
- *-----------------------------------------------------------------------------
- * JVMTI methods
- *-----------------------------------------------------------------------------
- */
-typedef struct JVMTINativeInterface_
-{
-  void *reserved1;
-    jvmtiError (JNICALL * SetEventNotificationMode) (jvmtiEnv * env,
-                                                     jvmtiEventMode mode,
-                                                     jvmtiEvent event_type,
-                                                     jthread event_thread,
-                                                     ...);
-  void *reserved3;
-    jvmtiError (JNICALL * GetAllThreads) (jvmtiEnv * env,
-                                          jint * threads_count_ptr,
-                                          jthread ** threads_ptr);
-    jvmtiError (JNICALL * SuspendThread) (jvmtiEnv * env, jthread thread);
-    jvmtiError (JNICALL * ResumeThread) (jvmtiEnv * env, jthread thread);
-    jvmtiError (JNICALL * StopThread) (jvmtiEnv * env, jthread thread,
-                                       jobject exception);
-    jvmtiError (JNICALL * InterruptThread) (jvmtiEnv * env, jthread thread);
-    jvmtiError (JNICALL * GetThreadInfo) (jvmtiEnv * env, jthread thread,
-                                          jvmtiThreadInfo * info_ptr);
-    jvmtiError (JNICALL * GetOwnedMonitorInfo) (jvmtiEnv * env,
-                                                jthread thread,
-                                                jint *
-                                                owned_monitor_count_ptr,
-                                                jobject **
-                                                owned_monitors_ptr);
-    jvmtiError (JNICALL * GetCurrentContendedMonitor) (jvmtiEnv * env,
-                                                       jthread thread,
-                                                       jobject * monitor_ptr);
-    jvmtiError (JNICALL * RunAgentThread) (jvmtiEnv * env, jthread thread,
-                                           jvmtiStartFunction proc,
-                                           const void *arg, jint priority);
-    jvmtiError (JNICALL * GetTopThreadGroups) (jvmtiEnv * env,
-                                               jint * group_count_ptr,
-                                               jthreadGroup ** groups_ptr);
-    jvmtiError (JNICALL * GetThreadGroupInfo) (jvmtiEnv * env,
-                                               jthreadGroup group,
-                                               jvmtiThreadGroupInfo *
-                                               info_ptr);
-    jvmtiError (JNICALL * GetThreadGroupChildren) (jvmtiEnv * env,
-                                                   jthreadGroup group,
-                                                   jint * thread_count_ptr,
-                                                   jthread ** threads_ptr,
-                                                   jint * group_count_ptr,
-                                                   jthreadGroup **
-                                                   groups_ptr);
-    jvmtiError (JNICALL * GetFrameCount) (jvmtiEnv * env, jthread thread,
-                                          jint * count_ptr);
-    jvmtiError (JNICALL * GetThreadState) (jvmtiEnv * env, jthread thread,
-                                           jint * thread_state_ptr);
-    void *reserved18;
-    jvmtiError (JNICALL * GetFrameLocation) (jvmtiEnv * env, jthread thread,
-                                             jint depth,
-                                             jmethodID * method_ptr,
-                                             jlocation * location_ptr);
-    jvmtiError (JNICALL * NotifyFramePop) (jvmtiEnv * env, jthread thread,
-                                           jint depth);
-    jvmtiError (JNICALL * GetLocalObject) (jvmtiEnv * env, jthread thread,
-                                           jint depth, jint slot,
-                                           jobject * value_ptr);
-    jvmtiError (JNICALL * GetLocalInt) (jvmtiEnv * env, jthread thread,
-                                        jint depth, jint slot,
-                                        jint * value_ptr);
-    jvmtiError (JNICALL * GetLocalLong) (jvmtiEnv * env, jthread thread,
-                                         jint depth, jint slot,
-                                         jlong * value_ptr);
-    jvmtiError (JNICALL * GetLocalFloat) (jvmtiEnv * env, jthread thread,
-                                          jint depth, jint slot,
-                                          jfloat * value_ptr);
-    jvmtiError (JNICALL * GetLocalDouble) (jvmtiEnv * env, jthread thread,
-                                           jint depth, jint slot,
-                                           jdouble * value_ptr);
-    jvmtiError (JNICALL * SetLocalObject) (jvmtiEnv * env, jthread thread,
-                                           jint depth, jint slot,
-                                           jobject value);
-    jvmtiError (JNICALL * SetLocalInt) (jvmtiEnv * env, jthread thread,
-                                        jint depth, jint slot, jint value);
-    jvmtiError (JNICALL * SetLocalLong) (jvmtiEnv * env, jthread thread,
-                                         jint depth, jint slot, jlong value);
-    jvmtiError (JNICALL * SetLocalFloat) (jvmtiEnv * env, jthread thread,
-                                          jint depth, jint slot,
-                                          jfloat value);
-    jvmtiError (JNICALL * SetLocalDouble) (jvmtiEnv * env, jthread thread,
-                                           jint depth, jint slot,
-                                           jdouble value);
-    jvmtiError (JNICALL * CreateRawMonitor) (jvmtiEnv * env, const char *name,
-                                             jrawMonitorID * monitor_ptr);
-    jvmtiError (JNICALL * DestroyRawMonitor) (jvmtiEnv * env,
-                                              jrawMonitorID monitor);
-    jvmtiError (JNICALL * RawMonitorEnter) (jvmtiEnv * env,
-                                            jrawMonitorID monitor);
-    jvmtiError (JNICALL * RawMonitorExit) (jvmtiEnv * env,
-                                           jrawMonitorID monitor);
-    jvmtiError (JNICALL * RawMonitorWait) (jvmtiEnv * env,
-                                           jrawMonitorID monitor,
-                                           jlong millis);
-    jvmtiError (JNICALL * RawMonitorNotify) (jvmtiEnv * env,
-                                             jrawMonitorID monitor);
-    jvmtiError (JNICALL * RawMonitorNotifyAll) (jvmtiEnv * env,
-                                                jrawMonitorID monitor);
-    jvmtiError (JNICALL * SetBreakpoint) (jvmtiEnv * env, jmethodID method,
-                                          jlocation location);
-    jvmtiError (JNICALL * ClearBreakpoint) (jvmtiEnv * env, jmethodID method,
-                                            jlocation location);
-    void *reserved40;
-    jvmtiError (JNICALL * SetFieldAccessWatch) (jvmtiEnv * env, jclass klass,
-                                                jfieldID field);
-    jvmtiError (JNICALL * ClearFieldAccessWatch) (jvmtiEnv * env,
-                                                  jclass klass,
-                                                  jfieldID field);
-    jvmtiError (JNICALL * SetFieldModificationWatch) (jvmtiEnv * env,
-                                                      jclass klass,
-                                                      jfieldID field);
-    jvmtiError (JNICALL * ClearFieldModificationWatch) (jvmtiEnv * env,
-                                                        jclass klass,
-                                                        jfieldID field);
-    void *reserved45;
-    jvmtiError (JNICALL * Allocate) (jvmtiEnv * env, jlong size,
-                                     unsigned char **mem_ptr);
     jvmtiError (JNICALL * Deallocate) (jvmtiEnv * env, unsigned char *mem);
-    jvmtiError (JNICALL * GetClassSignature) (jvmtiEnv * env, jclass klass,
-                                              char **signature_ptr,
-                                              char **generic_ptr);
-    jvmtiError (JNICALL * GetClassStatus) (jvmtiEnv * env, jclass klass,
-                                           jint * status_ptr);
-    jvmtiError (JNICALL * GetSourceFileName) (jvmtiEnv * env, jclass klass,
-                                              char **source_name_ptr);
-    jvmtiError (JNICALL * GetClassModifiers) (jvmtiEnv * env, jclass klass,
-                                              jint * modifiers_ptr);
-    jvmtiError (JNICALL * GetClassMethods) (jvmtiEnv * env, jclass klass,
-                                            jint * method_count_ptr,
-                                            jmethodID ** methods_ptr);
-    jvmtiError (JNICALL * GetClassFields) (jvmtiEnv * env, jclass klass,
-                                           jint * field_count_ptr,
-                                           jfieldID ** fields_ptr);
+
+    jvmtiError (JNICALL * GetClassSignature) (jvmtiEnv * env,
+        jclass clazz,
+        char **signature_ptr,
+        char **generic_ptr);
+
+    jvmtiError (JNICALL * GetClassStatus) (jvmtiEnv * env,
+        jclass clazz, jint * status_ptr);
+
+    jvmtiError (JNICALL * GetSourceFileName) (jvmtiEnv * env,
+        jclass clazz,
+        char **source_name_ptr);
+
+    jvmtiError (JNICALL * GetClassModifiers) (jvmtiEnv * env,
+        jclass clazz,
+        jint * modifiers_ptr);
+
+    jvmtiError (JNICALL * GetClassMethods) (jvmtiEnv * env,
+        jclass clazz,
+        jint * method_count_ptr,
+        jmethodID ** methods_ptr);
+
+    jvmtiError (JNICALL * GetClassFields) (jvmtiEnv * env,
+        jclass clazz,
+        jint * field_count_ptr,
+        jfieldID ** fields_ptr);
+
     jvmtiError (JNICALL * GetImplementedInterfaces) (jvmtiEnv * env,
-                                                     jclass klass,
-                                                     jint *
-                                                     interface_count_ptr,
-                                                     jclass **
-                                                     interfaces_ptr);
-    jvmtiError (JNICALL * IsInterface) (jvmtiEnv * env, jclass klass,
-                                        jboolean * is_interface_ptr);
-    jvmtiError (JNICALL * IsArrayClass) (jvmtiEnv * env, jclass klass,
-                                         jboolean * is_array_class_ptr);
-    jvmtiError (JNICALL * GetClassLoader) (jvmtiEnv * env, jclass klass,
-                                           jobject * classloader_ptr);
-    jvmtiError (JNICALL * GetObjectHashCode) (jvmtiEnv * env, jobject object,
-                                              jint * hash_code_ptr);
+        jclass clazz,
+        jint *
+        interface_count_ptr,
+        jclass **
+        interfaces_ptr);
+
+    jvmtiError (JNICALL * IsInterface) (jvmtiEnv * env,
+        jclass clazz,
+        jboolean * is_interface_ptr);
+
+    jvmtiError (JNICALL * IsArrayClass) (jvmtiEnv * env,
+        jclass clazz,
+        jboolean * is_array_class_ptr);
+
+    jvmtiError (JNICALL * GetClassLoader) (jvmtiEnv * env,
+        jclass clazz,
+        jobject * classloader_ptr);
+
+    jvmtiError (JNICALL * GetObjectHashCode) (jvmtiEnv * env,
+        jobject object,
+        jint * hash_code_ptr);
+
     jvmtiError (JNICALL * GetObjectMonitorUsage) (jvmtiEnv * env,
-                                                  jobject object,
-                                                  jvmtiMonitorUsage *
-                                                  info_ptr);
-    jvmtiError (JNICALL * GetFieldName) (jvmtiEnv * env, jclass klass,
-                                         jfieldID field, char **name_ptr,
-                                         char **signature_ptr,
-                                         char **generic_ptr);
+        jobject object,
+        jvmtiMonitorUsage *
+        info_ptr);
+
+    jvmtiError (JNICALL * GetFieldName) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field,
+        char **name_ptr,
+        char **signature_ptr,
+        char **generic_ptr);
+
     jvmtiError (JNICALL * GetFieldDeclaringClass) (jvmtiEnv * env,
-                                                   jclass klass,
-                                                   jfieldID field,
-                                                   jclass *
-                                                   declaring_class_ptr);
-    jvmtiError (JNICALL * GetFieldModifiers) (jvmtiEnv * env, jclass klass,
-                                              jfieldID field,
-                                              jint * modifiers_ptr);
-    jvmtiError (JNICALL * IsFieldSynthetic) (jvmtiEnv * env, jclass klass,
-                                             jfieldID field,
-                                             jboolean * is_synthetic_ptr);
-    jvmtiError (JNICALL * GetMethodName) (jvmtiEnv * env, jmethodID method,
-                                          char **name_ptr,
-                                          char **signature_ptr,
-                                          char **generic_ptr);
+        jclass clazz,
+        jfieldID field,
+        jclass *
+        declaring_class_ptr);
+
+    jvmtiError (JNICALL * GetFieldModifiers) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field,
+        jint * modifiers_ptr);
+
+    jvmtiError (JNICALL * IsFieldSynthetic) (jvmtiEnv * env,
+        jclass clazz,
+        jfieldID field,
+        jboolean * is_synthetic_ptr);
+
+    jvmtiError (JNICALL * GetMethodName) (jvmtiEnv * env,
+        jmethodID method,
+        char **name_ptr,
+        char **signature_ptr,
+        char **generic_ptr);
+
     jvmtiError (JNICALL * GetMethodDeclaringClass) (jvmtiEnv * env,
-                                                    jmethodID method,
-                                                    jclass *
-                                                    declaring_class_ptr);
+        jmethodID method,
+        jclass *
+        declaring_class_ptr);
+
     jvmtiError (JNICALL * GetMethodModifiers) (jvmtiEnv * env,
-                                               jmethodID method,
-                                               jint * modifiers_ptr);
+        jmethodID method,
+        jint * modifiers_ptr);
+
     void *reserved67;
-    jvmtiError (JNICALL * GetMaxLocals) (jvmtiEnv * env, jmethodID method,
-                                         jint * max_ptr);
-    jvmtiError (JNICALL * GetArgumentsSize) (jvmtiEnv * env, jmethodID method,
-                                             jint * size_ptr);
+
+    jvmtiError (JNICALL * GetMaxLocals) (jvmtiEnv * env,
+        jmethodID method, jint * max_ptr);
+
+    jvmtiError (JNICALL * GetArgumentsSize) (jvmtiEnv * env,
+        jmethodID method,
+        jint * size_ptr);
+
     jvmtiError (JNICALL * GetLineNumberTable) (jvmtiEnv * env,
-                                               jmethodID method,
-                                               jint * entry_count_ptr,
-                                               jvmtiLineNumberEntry **
-                                               table_ptr);
+        jmethodID method,
+        jint * entry_count_ptr,
+        jvmtiLineNumberEntry **
+        table_ptr);
+
     jvmtiError (JNICALL * GetMethodLocation) (jvmtiEnv * env,
-                                              jmethodID method,
-                                              jlocation * start_location_ptr,
-                                              jlocation * end_location_ptr);
+        jmethodID method,
+        jlocation * start_location_ptr,
+        jlocation * end_location_ptr);
+
     jvmtiError (JNICALL * GetLocalVariableTable) (jvmtiEnv * env,
-                                                  jmethodID method,
-                                                  jint * entry_count_ptr,
-                                                  jvmtiLocalVariableEntry **
-                                                  table_ptr);
+        jmethodID method,
+        jint * entry_count_ptr,
+        jvmtiLocalVariableEntry **
+        table_ptr);
+
     void *reserved73;
+
     void *reserved74;
-    jvmtiError (JNICALL * GetBytecodes) (jvmtiEnv * env, jmethodID method,
-                                         jint * bytecode_count_ptr,
-                                         unsigned char **bytecodes_ptr);
-    jvmtiError (JNICALL * IsMethodNative) (jvmtiEnv * env, jmethodID method,
-                                           jboolean * is_native_ptr);
+
+    jvmtiError (JNICALL * GetBytecodes) (jvmtiEnv * env,
+        jmethodID method,
+        jint * bytecode_count_ptr,
+        unsigned char **bytecodes_ptr);
+
+    jvmtiError (JNICALL * IsMethodNative) (jvmtiEnv * env,
+        jmethodID method,
+        jboolean * is_native_ptr);
+
     jvmtiError (JNICALL * IsMethodSynthetic) (jvmtiEnv * env,
-                                              jmethodID method,
-                                              jboolean * is_synthetic_ptr);
+        jmethodID method,
+        jboolean * is_synthetic_ptr);
+
     jvmtiError (JNICALL * GetLoadedClasses) (jvmtiEnv * env,
-                                             jint * class_count_ptr,
-                                             jclass ** classes_ptr);
+        jint * class_count_ptr,
+        jclass ** classes_ptr);
+
     jvmtiError (JNICALL * GetClassLoaderClasses) (jvmtiEnv * env,
-                                                  jobject initiating_loader,
-                                                  jint * class_count_ptr,
-                                                  jclass ** classes_ptr);
+        jobject initiating_loader,
+        jint * class_count_ptr,
+        jclass ** classes_ptr);
+
     jvmtiError (JNICALL * PopFrame) (jvmtiEnv * env, jthread thread);
+
     void *reserved81;
+
     void *reserved82;
+
     void *reserved83;
+
     void *reserved84;
+
     void *reserved85;
+
     void *reserved86;
-    jvmtiError (JNICALL * RedefineClasses) (jvmtiEnv * env, jint class_count,
-                                            const jvmtiClassDefinition *
-                                            class_definitions);
+
+    jvmtiError (JNICALL * RedefineClasses) (jvmtiEnv * env,
+        jint class_count,
+        const jvmtiClassDefinition *
+        class_definitions);
+
     jvmtiError (JNICALL * GetVersionNumber) (jvmtiEnv * env,
-                                             jint * version_ptr);
+        jint * version_ptr);
+
     jvmtiError (JNICALL * GetCapabilities) (jvmtiEnv * env,
-                                            jvmtiCapabilities *
-                                            capabilities_ptr);
+        jvmtiCapabilities *
+        capabilities_ptr);
+
     jvmtiError (JNICALL * GetSourceDebugExtension) (jvmtiEnv * env,
-                                                    jclass klass,
-                                                    char
-                                                    **source_debug_extension_ptr);
-    jvmtiError (JNICALL * IsMethodObsolete) (jvmtiEnv * env, jmethodID method,
-                                             jboolean * is_obsolete_ptr);
+        jclass clazz,
+        char
+        **source_debug_extension_ptr);
+
+    jvmtiError (JNICALL * IsMethodObsolete) (jvmtiEnv * env,
+        jmethodID method,
+        jboolean * is_obsolete_ptr);
+
     jvmtiError (JNICALL * SuspendThreadList) (jvmtiEnv * env,
-                                              jint request_count,
-                                              const jthread * request_list,
-                                              jvmtiError * results);
+        jint request_count,
+        const jthread * request_list,
+        jvmtiError * results);
+
     jvmtiError (JNICALL * ResumeThreadList) (jvmtiEnv * env,
-                                             jint request_count,
-                                             const jthread * request_list,
-                                             jvmtiError * results);
+        jint request_count,
+        const jthread * request_list,
+        jvmtiError * results);
+
     void *reserved94;
+
     void *reserved95;
+
     void *reserved96;
+
     void *reserved97;
+
     void *reserved98;
+
     void *reserved99;
+
     jvmtiError (JNICALL * GetAllStackTraces) (jvmtiEnv * env,
-                                              jint max_frame_count,
-                                              jvmtiStackInfo **
-                                              stack_info_ptr,
-                                              jint * thread_count_ptr);
+        jint max_frame_count,
+        jvmtiStackInfo **
+        stack_info_ptr,
+        jint * thread_count_ptr);
+
     jvmtiError (JNICALL * GetThreadListStackTraces) (jvmtiEnv * env,
-                                                     jint thread_count,
-                                                     const jthread *
-                                                     thread_list,
-                                                     jint max_frame_count,
-                                                     jvmtiStackInfo **
-                                                     stack_info_ptr);
+        jint thread_count,
+        const jthread *
+        thread_list,
+        jint max_frame_count,
+        jvmtiStackInfo **
+        stack_info_ptr);
+
     jvmtiError (JNICALL * GetThreadLocalStorage) (jvmtiEnv * env,
-                                                  jthread thread,
-                                                  void **data_ptr);
+        jthread thread,
+        void **data_ptr);
+
     jvmtiError (JNICALL * SetThreadLocalStorage) (jvmtiEnv * env,
-                                                  jthread thread,
-                                                  const void *data);
-    jvmtiError (JNICALL * GetStackTrace) (jvmtiEnv * env, jthread thread,
-                                          jint start_depth,
-                                          jint max_frame_count,
-                                          jvmtiFrameInfo * frame_buffer,
-                                          jint * count_ptr);
+        jthread thread,
+        const void *data);
+
+    jvmtiError (JNICALL * GetStackTrace) (jvmtiEnv * env,
+        jthread thread,
+        jint start_depth,
+        jint max_frame_count,
+        jvmtiFrameInfo * frame_buffer,
+        jint * count_ptr);
+
     void *reserved105;
-    jvmtiError (JNICALL * GetTag) (jvmtiEnv * env, jobject object,
-                                   jlong * tag_ptr);
+
+    jvmtiError (JNICALL * GetTag) (jvmtiEnv * env,
+        jobject object, jlong * tag_ptr);
+
     jvmtiError (JNICALL * SetTag) (jvmtiEnv * env, jobject object, jlong tag);
+
     jvmtiError (JNICALL * ForceGarbageCollection) (jvmtiEnv * env);
+
     jvmtiError (JNICALL * IterateOverObjectsReachableFromObject) (jvmtiEnv *
-                                                                  env,
-                                                                  jobject
-                                                                  object,
-                                                                  jvmtiObjectReferenceCallback
-                                                                  object_reference_callback,
-                                                                  void
-                                                                  *user_data);
+        env,
+        jobject
+        object,
+        jvmtiObjectReferenceCallback
+        object_reference_callback,
+        void
+        *user_data);
+
     jvmtiError (JNICALL * IterateOverReachableObjects) (jvmtiEnv * env,
-                                                        jvmtiHeapRootCallback
-                                                        heap_root_callback,
-                                                        jvmtiStackReferenceCallback
-                                                        stack_ref_callback,
-                                                        jvmtiObjectReferenceCallback
-                                                        object_ref_callback,
-                                                        void *user_data);
+        jvmtiHeapRootCallback
+        heap_root_callback,
+        jvmtiStackReferenceCallback
+        stack_ref_callback,
+        jvmtiObjectReferenceCallback
+        object_ref_callback,
+        void *user_data);
+
     jvmtiError (JNICALL * IterateOverHeap) (jvmtiEnv * env,
-                                            jvmtiHeapObjectFilter
-                                            object_filter,
-                                            jvmtiHeapObjectCallback
-                                            heap_object_callback,
-                                            void *user_data);
+        jvmtiHeapObjectFilter
+        object_filter,
+        jvmtiHeapObjectCallback
+        heap_object_callback,
+        void *user_data);
+
     jvmtiError (JNICALL * IterateOverInstancesOfClass) (jvmtiEnv * env,
-                                                        jclass klass,
-                                                        jvmtiHeapObjectFilter
-                                                        object_filter,
-                                                        jvmtiHeapObjectCallback
-                                                        heap_object_callback,
-                                                        void *user_data);
+        jclass clazz,
+        jvmtiHeapObjectFilter
+        object_filter,
+        jvmtiHeapObjectCallback
+        heap_object_callback,
+        void *user_data);
+
     void *reserved113;
-    jvmtiError (JNICALL * GetObjectsWithTags) (jvmtiEnv * env, jint tag_count,
-                                               const jlong * tags,
-                                               jint * count_ptr,
-                                               jobject ** object_result_ptr,
-                                               jlong ** tag_result_ptr);
+
+    jvmtiError (JNICALL * GetObjectsWithTags) (jvmtiEnv * env,
+        jint tag_count,
+        const jlong * tags,
+        jint * count_ptr,
+        jobject ** object_result_ptr,
+        jlong ** tag_result_ptr);
+
     void *reserved115;
+
     void *reserved116;
+
     void *reserved117;
+
     void *reserved118;
+
     void *reserved119;
+
     jvmtiError (JNICALL * SetJNIFunctionTable) (jvmtiEnv * env,
-                                                const jniNativeInterface *
-                                                function_table);
+        const jniNativeInterface *
+        function_table);
+
     jvmtiError (JNICALL * GetJNIFunctionTable) (jvmtiEnv * env,
-                                                jniNativeInterface **
-                                                function_table);
+        jniNativeInterface **
+        function_table);
+
     jvmtiError (JNICALL * SetEventCallbacks) (jvmtiEnv * env,
-                                              const jvmtiEventCallbacks *
-                                              callbacks,
-                                              jint size_of_callbacks);
+        const jvmtiEventCallbacks *
+        callbacks,
+        jint size_of_callbacks);
+
     jvmtiError (JNICALL * GenerateEvents) (jvmtiEnv * env,
-                                           jvmtiEvent event_type);
+        jvmtiEvent event_type);
+
     jvmtiError (JNICALL * GetExtensionFunctions) (jvmtiEnv * env,
-                                                  jint * extension_count_ptr,
-                                                  jvmtiExtensionFunctionInfo
-                                                  ** extensions);
+        jint * extension_count_ptr,
+        jvmtiExtensionFunctionInfo
+        ** extensions);
+
     jvmtiError (JNICALL * GetExtensionEvents) (jvmtiEnv * env,
-                                               jint * extension_count_ptr,
-                                               jvmtiExtensionEventInfo **
-                                               extensions);
+        jint * extension_count_ptr,
+        jvmtiExtensionEventInfo **
+        extensions);
+
     jvmtiError (JNICALL * SetExtensionEventCallback) (jvmtiEnv * env,
-                                                      jint
-                                                      extension_event_index,
-                                                      jvmtiExtensionEvent
-                                                      callback);
+        jint
+        extension_event_index,
+        jvmtiExtensionEvent
+        callback);
+
     jvmtiError (JNICALL * DisposeEnvironment) (jvmtiEnv * env);
-    jvmtiError (JNICALL * GetErrorName) (jvmtiEnv * env, jvmtiError error,
-                                         char **name_ptr);
+
+    jvmtiError (JNICALL * GetErrorName) (jvmtiEnv * env,
+        jvmtiError error, char **name_ptr);
+
     jvmtiError (JNICALL * GetJLocationFormat) (jvmtiEnv * env,
-                                               jvmtiJlocationFormat *
-                                               format_ptr);
+        jvmtiJlocationFormat *
+        format_ptr);
+
     jvmtiError (JNICALL * GetSystemProperties) (jvmtiEnv * env,
-                                                jint * count_ptr,
-                                                char ***property_ptr);
+        jint * count_ptr,
+        char ***property_ptr);
+
     jvmtiError (JNICALL * GetSystemProperty) (jvmtiEnv * env,
-                                              const char *property,
-                                              char **value_ptr);
+        const char *property,
+        char **value_ptr);
+
     jvmtiError (JNICALL * SetSystemProperty) (jvmtiEnv * env,
-                                              const char *property,
-                                              const char *value);
+        const char *property,
+        const char *value);
+
     jvmtiError (JNICALL * GetPhase) (jvmtiEnv * env, jvmtiPhase * phase_ptr);
+
     jvmtiError (JNICALL * GetCurrentThreadCpuTimerInfo) (jvmtiEnv * env,
-                                                         jvmtiTimerInfo *
-                                                         info_ptr);
+        jvmtiTimerInfo *
+        info_ptr);
+
     jvmtiError (JNICALL * GetCurrentThreadCpuTime) (jvmtiEnv * env,
-                                                    jlong * nanos_ptr);
+        jlong * nanos_ptr);
+
     jvmtiError (JNICALL * GetThreadCpuTimerInfo) (jvmtiEnv * env,
-                                                  jvmtiTimerInfo * info_ptr);
-    jvmtiError (JNICALL * GetThreadCpuTime) (jvmtiEnv * env, jthread thread,
-                                             jlong * nanos_ptr);
+        jvmtiTimerInfo * info_ptr);
+
+    jvmtiError (JNICALL * GetThreadCpuTime) (jvmtiEnv * env,
+        jthread thread,
+        jlong * nanos_ptr);
+
     jvmtiError (JNICALL * GetTimerInfo) (jvmtiEnv * env,
-                                         jvmtiTimerInfo * info_ptr);
+        jvmtiTimerInfo * info_ptr);
+
     jvmtiError (JNICALL * GetTime) (jvmtiEnv * env, jlong * nanos_ptr);
+
+
     jvmtiError (JNICALL * GetPotentialCapabilities) (jvmtiEnv * env,
-                                                     jvmtiCapabilities *
-                                                     capabilities_ptr);
+        jvmtiCapabilities *
+        capabilities_ptr);
+
     void *reserved141;
+
     jvmtiError (JNICALL * AddCapabilities) (jvmtiEnv * env,
-                                            const jvmtiCapabilities *
-                                            capabilities_ptr);
+        const jvmtiCapabilities *
+        capabilities_ptr);
+
     jvmtiError (JNICALL * RelinquishCapabilities) (jvmtiEnv * env,
-                                                   const jvmtiCapabilities *
-                                                   capabilities_ptr);
+        const jvmtiCapabilities *
+        capabilities_ptr);
+
     jvmtiError (JNICALL * GetAvailableProcessors) (jvmtiEnv * env,
-                                                   jint *
-                                                   processor_count_ptr);
+        jint *
+        processor_count_ptr);
+
     void *reserved145;
+
     void *reserved146;
+
     jvmtiError (JNICALL * GetEnvironmentLocalStorage) (jvmtiEnv * env,
-                                                       void **data_ptr);
+        void **data_ptr);
+
     jvmtiError (JNICALL * SetEnvironmentLocalStorage) (jvmtiEnv * env,
-                                                       const void *data);
+        const void *data);
+
     jvmtiError (JNICALL * AddToBootstrapClassLoaderSearch) (jvmtiEnv * env,
-                                                            const char
-                                                            *segment);
+        const char
+        *segment);
+
     jvmtiError (JNICALL * SetVerboseFlag) (jvmtiEnv * env,
-                                           jvmtiVerboseFlag flag,
-                                           jboolean value);
+        jvmtiVerboseFlag flag,
+        jboolean value);
+
     void *reserved151;
+
     void *reserved152;
+
     void *reserved153;
-    jvmtiError (JNICALL * GetObjectSize) (jvmtiEnv * env, jobject object,
-                                          jlong * size_ptr);
-} jvmtiNativeInterface;
 
-#endif /* jvmti_h */
+    jvmtiError (JNICALL * GetObjectSize) (jvmtiEnv * env,
+        jobject object, jlong * size_ptr);
+};
+
+
+struct jvmtiEnv_struct
+{
+    const struct ti_interface *funcs;
+
+#ifdef __cplusplus
+
+    jvmtiError Allocate (jlong size, unsigned char **mem_ptr)
+    {
+        return funcs->Allocate (this, size, mem_ptr);
+    }
+
+    jvmtiError Deallocate (unsigned char *mem)
+    {
+        return funcs->Deallocate (this, mem);
+    }
+
+    jvmtiError GetThreadState (jthread thread, jint * thread_state_ptr)
+    {
+        return funcs->GetThreadState (this, thread, thread_state_ptr);
+    }
+
+    jvmtiError GetAllThreads (jint * threads_count_ptr, jthread ** threads_ptr)
+    {
+        return funcs->GetAllThreads (this, threads_count_ptr, threads_ptr);
+    }
+
+    jvmtiError SuspendThread (jthread thread)
+    {
+        return funcs->SuspendThread (this, thread);
+    }
+
+    jvmtiError SuspendThreadList (jint request_count,
+        const jthread * request_list,
+        jvmtiError * results)
+    {
+        return funcs->SuspendThreadList (this, request_count, request_list,
+            results);
+    }
+
+    jvmtiError ResumeThread (jthread thread)
+    {
+        return funcs->ResumeThread (this, thread);
+    }
+
+    jvmtiError ResumeThreadList (jint request_count,
+        const jthread * request_list,
+        jvmtiError * results)
+    {
+        return funcs->ResumeThreadList (this, request_count, request_list,
+            results);
+    }
+
+    jvmtiError StopThread (jthread thread, jobject exception)
+    {
+        return funcs->StopThread (this, thread, exception);
+    }
+
+    jvmtiError InterruptThread (jthread thread)
+    {
+        return funcs->InterruptThread (this, thread);
+    }
+
+    jvmtiError GetThreadInfo (jthread thread, jvmtiThreadInfo * info_ptr)
+    {
+        return funcs->GetThreadInfo (this, thread, info_ptr);
+    }
+
+    jvmtiError GetOwnedMonitorInfo (jthread thread,
+        jint * owned_monitor_count_ptr,
+        jobject ** owned_monitors_ptr)
+    {
+        return funcs->GetOwnedMonitorInfo (this, thread,
+            owned_monitor_count_ptr,
+            owned_monitors_ptr);
+    }
+
+    jvmtiError GetCurrentContendedMonitor (jthread thread,
+        jobject * monitor_ptr)
+    {
+        return funcs->GetCurrentContendedMonitor (this, thread, monitor_ptr);
+    }
+
+    jvmtiError RunAgentThread (jthread thread,
+        jvmtiStartFunction proc,
+        const void *arg, jint priority)
+    {
+        return funcs->RunAgentThread (this, thread, proc, arg, priority);
+    }
+
+    jvmtiError SetThreadLocalStorage (jthread thread, const void *data)
+    {
+        return funcs->SetThreadLocalStorage (this, thread, data);
+    }
+
+    jvmtiError GetThreadLocalStorage (jthread thread, void **data_ptr)
+    {
+        return funcs->GetThreadLocalStorage (this, thread, data_ptr);
+    }
+
+    jvmtiError GetTopThreadGroups (jint * group_count_ptr,
+        jthreadGroup ** groups_ptr)
+    {
+        return funcs->GetTopThreadGroups (this, group_count_ptr, groups_ptr);
+    }
+
+    jvmtiError GetThreadGroupInfo (jthreadGroup group,
+        jvmtiThreadGroupInfo * info_ptr)
+    {
+        return funcs->GetThreadGroupInfo (this, group, info_ptr);
+    }
+
+    jvmtiError GetThreadGroupChildren (jthreadGroup group,
+        jint * thread_count_ptr,
+        jthread ** threads_ptr,
+        jint * group_count_ptr,
+        jthreadGroup ** groups_ptr)
+    {
+        return funcs->GetThreadGroupChildren (this, group, thread_count_ptr,
+            threads_ptr, group_count_ptr,
+            groups_ptr);
+    }
+
+    jvmtiError GetStackTrace (jthread thread,
+        jint start_depth,
+        jint max_frame_count,
+        jvmtiFrameInfo * frame_buffer, jint * count_ptr)
+    {
+        return funcs->GetStackTrace (this, thread, start_depth,
+            max_frame_count, frame_buffer, count_ptr);
+    }
+
+    jvmtiError GetAllStackTraces (jint max_frame_count,
+        jvmtiStackInfo ** stack_info_ptr,
+        jint * thread_count_ptr)
+    {
+        return funcs->GetAllStackTraces (this, max_frame_count,
+            stack_info_ptr, thread_count_ptr);
+    }
+
+    jvmtiError GetThreadListStackTraces (jint thread_count,
+        const jthread * thread_list,
+        jint max_frame_count,
+        jvmtiStackInfo ** stack_info_ptr)
+    {
+        return funcs->GetThreadListStackTraces (this, thread_count,
+            thread_list, max_frame_count,
+            stack_info_ptr);
+    }
+
+    jvmtiError GetFrameCount (jthread thread, jint * count_ptr)
+    {
+        return funcs->GetFrameCount (this, thread, count_ptr);
+    }
+
+    jvmtiError PopFrame (jthread thread)
+    {
+        return funcs->PopFrame (this, thread);
+    }
+
+    jvmtiError GetFrameLocation (jthread thread,
+        jint depth,
+        jmethodID * method_ptr,
+        jlocation * location_ptr)
+    {
+        return funcs->GetFrameLocation (this, thread, depth, method_ptr,
+            location_ptr);
+    }
+
+    jvmtiError NotifyFramePop (jthread thread, jint depth)
+    {
+        return funcs->NotifyFramePop (this, thread, depth);
+    }
+
+    jvmtiError GetTag (jobject object, jlong * tag_ptr)
+    {
+        return funcs->GetTag (this, object, tag_ptr);
+    }
+
+    jvmtiError SetTag (jobject object, jlong tag)
+    {
+        return funcs->SetTag (this, object, tag);
+    }
+
+    jvmtiError ForceGarbageCollection ()
+    {
+        return funcs->ForceGarbageCollection (this);
+    }
+
+    jvmtiError IterateOverObjectsReachableFromObject (jobject object,
+        jvmtiObjectReferenceCallback
+        object_reference_callback,
+        void *user_data)
+    {
+        return funcs->IterateOverObjectsReachableFromObject (this, object,
+            object_reference_callback,
+            user_data);
+    }
+
+    jvmtiError IterateOverReachableObjects (jvmtiHeapRootCallback
+        heap_root_callback,
+        jvmtiStackReferenceCallback
+        stack_ref_callback,
+        jvmtiObjectReferenceCallback
+        object_ref_callback,
+        void *user_data)
+    {
+        return funcs->IterateOverReachableObjects (this, heap_root_callback,
+            stack_ref_callback,
+            object_ref_callback,
+            user_data);
+    }
+
+    jvmtiError IterateOverHeap (jvmtiHeapObjectFilter object_filter,
+        jvmtiHeapObjectCallback heap_object_callback,
+        void *user_data)
+    {
+        return funcs->IterateOverHeap (this, object_filter,
+            heap_object_callback, user_data);
+    }
+
+    jvmtiError IterateOverInstancesOfClass (jclass clazz,
+        jvmtiHeapObjectFilter object_filter,
+        jvmtiHeapObjectCallback
+        heap_object_callback,
+        void *user_data)
+    {
+        return funcs->IterateOverInstancesOfClass (this, clazz, object_filter,
+            heap_object_callback,
+            user_data);
+    }
+
+    jvmtiError GetObjectsWithTags (jint tag_count,
+        const jlong * tags,
+        jint * count_ptr,
+        jobject ** object_result_ptr,
+        jlong ** tag_result_ptr)
+    {
+        return funcs->GetObjectsWithTags (this, tag_count, tags, count_ptr,
+            object_result_ptr, tag_result_ptr);
+    }
+
+    jvmtiError GetLocalObject (jthread thread,
+        jint depth, jint slot, jobject * value_ptr)
+    {
+        return funcs->GetLocalObject (this, thread, depth, slot, value_ptr);
+    }
+
+    jvmtiError GetLocalInt (jthread thread,
+        jint depth, jint slot, jint * value_ptr)
+    {
+        return funcs->GetLocalInt (this, thread, depth, slot, value_ptr);
+    }
+
+    jvmtiError GetLocalLong (jthread thread,
+        jint depth, jint slot, jlong * value_ptr)
+    {
+        return funcs->GetLocalLong (this, thread, depth, slot, value_ptr);
+    }
+
+    jvmtiError GetLocalFloat (jthread thread,
+        jint depth, jint slot, jfloat * value_ptr)
+    {
+        return funcs->GetLocalFloat (this, thread, depth, slot, value_ptr);
+    }
+
+    jvmtiError GetLocalDouble (jthread thread,
+        jint depth, jint slot, jdouble * value_ptr)
+    {
+        return funcs->GetLocalDouble (this, thread, depth, slot, value_ptr);
+    }
+
+    jvmtiError SetLocalObject (jthread thread,
+        jint depth, jint slot, jobject value)
+    {
+        return funcs->SetLocalObject (this, thread, depth, slot, value);
+    }
+
+    jvmtiError SetLocalInt (jthread thread, jint depth, jint slot, jint value)
+    {
+        return funcs->SetLocalInt (this, thread, depth, slot, value);
+    }
+
+    jvmtiError SetLocalLong (jthread thread, jint depth, jint slot, jlong value)
+    {
+        return funcs->SetLocalLong (this, thread, depth, slot, value);
+    }
+
+    jvmtiError SetLocalFloat (jthread thread,
+        jint depth, jint slot, jfloat value)
+    {
+        return funcs->SetLocalFloat (this, thread, depth, slot, value);
+    }
+
+    jvmtiError SetLocalDouble (jthread thread,
+        jint depth, jint slot, jdouble value)
+    {
+        return funcs->SetLocalDouble (this, thread, depth, slot, value);
+    }
+
+    jvmtiError SetBreakpoint (jmethodID method, jlocation location)
+    {
+        return funcs->SetBreakpoint (this, method, location);
+    }
+
+    jvmtiError ClearBreakpoint (jmethodID method, jlocation location)
+    {
+        return funcs->ClearBreakpoint (this, method, location);
+    }
+
+    jvmtiError SetFieldAccessWatch (jclass clazz, jfieldID field)
+    {
+        return funcs->SetFieldAccessWatch (this, clazz, field);
+    }
+
+    jvmtiError ClearFieldAccessWatch (jclass clazz, jfieldID field)
+    {
+        return funcs->ClearFieldAccessWatch (this, clazz, field);
+    }
+
+    jvmtiError SetFieldModificationWatch (jclass clazz, jfieldID field)
+    {
+        return funcs->SetFieldModificationWatch (this, clazz, field);
+    }
+
+    jvmtiError ClearFieldModificationWatch (jclass clazz, jfieldID field)
+    {
+        return funcs->ClearFieldModificationWatch (this, clazz, field);
+    }
+
+    jvmtiError GetLoadedClasses (jint * class_count_ptr, jclass ** classes_ptr)
+    {
+        return funcs->GetLoadedClasses (this, class_count_ptr, classes_ptr);
+    }
+
+    jvmtiError GetClassLoaderClasses (jobject initiating_loader,
+        jint * class_count_ptr,
+        jclass ** classes_ptr)
+    {
+        return funcs->GetClassLoaderClasses (this, initiating_loader,
+            class_count_ptr, classes_ptr);
+    }
+
+    jvmtiError GetClassSignature (jclass clazz,
+        char **signature_ptr, char **generic_ptr)
+    {
+        return funcs->GetClassSignature (this, clazz, signature_ptr, generic_ptr);
+    }
+
+    jvmtiError GetClassStatus (jclass clazz, jint * status_ptr)
+    {
+        return funcs->GetClassStatus (this, clazz, status_ptr);
+    }
+
+    jvmtiError GetSourceFileName (jclass clazz, char **source_name_ptr)
+    {
+        return funcs->GetSourceFileName (this, clazz, source_name_ptr);
+    }
+
+    jvmtiError GetClassModifiers (jclass clazz, jint * modifiers_ptr)
+    {
+        return funcs->GetClassModifiers (this, clazz, modifiers_ptr);
+    }
+
+    jvmtiError GetClassMethods (jclass clazz,
+        jint * method_count_ptr,
+        jmethodID ** methods_ptr)
+    {
+        return funcs->GetClassMethods (this, clazz, method_count_ptr,
+            methods_ptr);
+    }
+
+    jvmtiError GetClassFields (jclass clazz,
+        jint * field_count_ptr, jfieldID ** fields_ptr)
+    {
+        return funcs->GetClassFields (this, clazz, field_count_ptr, fields_ptr);
+    }
+
+    jvmtiError GetImplementedInterfaces (jclass clazz,
+        jint * interface_count_ptr,
+        jclass ** interfaces_ptr)
+    {
+        return funcs->GetImplementedInterfaces (this, clazz,
+            interface_count_ptr,
+            interfaces_ptr);
+    }
+
+    jvmtiError IsInterface (jclass clazz, jboolean * is_interface_ptr)
+    {
+        return funcs->IsInterface (this, clazz, is_interface_ptr);
+    }
+
+    jvmtiError IsArrayClass (jclass clazz, jboolean * is_array_class_ptr)
+    {
+        return funcs->IsArrayClass (this, clazz, is_array_class_ptr);
+    }
+
+    jvmtiError GetClassLoader (jclass clazz, jobject * classloader_ptr)
+    {
+        return funcs->GetClassLoader (this, clazz, classloader_ptr);
+    }
+
+    jvmtiError GetSourceDebugExtension (jclass clazz,
+        char **source_debug_extension_ptr)
+    {
+        return funcs->GetSourceDebugExtension (this, clazz,
+            source_debug_extension_ptr);
+    }
+
+    jvmtiError RedefineClasses (jint class_count,
+        const jvmtiClassDefinition * class_definitions)
+    {
+        return funcs->RedefineClasses (this, class_count, class_definitions);
+    }
+
+    jvmtiError GetObjectSize (jobject object, jlong * size_ptr)
+    {
+        return funcs->GetObjectSize (this, object, size_ptr);
+    }
+
+    jvmtiError GetObjectHashCode (jobject object, jint * hash_code_ptr)
+    {
+        return funcs->GetObjectHashCode (this, object, hash_code_ptr);
+    }
+
+    jvmtiError GetObjectMonitorUsage (jobject object,
+        jvmtiMonitorUsage * info_ptr)
+    {
+        return funcs->GetObjectMonitorUsage (this, object, info_ptr);
+    }
+
+    jvmtiError GetFieldName (jclass clazz,
+        jfieldID field,
+        char **name_ptr,
+        char **signature_ptr, char **generic_ptr)
+    {
+        return funcs->GetFieldName (this, clazz, field, name_ptr,
+            signature_ptr, generic_ptr);
+    }
+
+    jvmtiError GetFieldDeclaringClass (jclass clazz,
+        jfieldID field,
+        jclass * declaring_class_ptr)
+    {
+        return funcs->GetFieldDeclaringClass (this, clazz, field,
+            declaring_class_ptr);
+    }
+
+    jvmtiError GetFieldModifiers (jclass clazz,
+        jfieldID field, jint * modifiers_ptr)
+    {
+        return funcs->GetFieldModifiers (this, clazz, field, modifiers_ptr);
+    }
+
+    jvmtiError IsFieldSynthetic (jclass clazz,
+        jfieldID field, jboolean * is_synthetic_ptr)
+    {
+        return funcs->IsFieldSynthetic (this, clazz, field, is_synthetic_ptr);
+    }
+
+    jvmtiError GetMethodName (jmethodID method,
+        char **name_ptr,
+        char **signature_ptr, char **generic_ptr)
+    {
+        return funcs->GetMethodName (this, method, name_ptr, signature_ptr,
+            generic_ptr);
+    }
+
+    jvmtiError GetMethodDeclaringClass (jmethodID method,
+        jclass * declaring_class_ptr)
+    {
+        return funcs->GetMethodDeclaringClass (this, method, declaring_class_ptr);
+    }
+
+    jvmtiError GetMethodModifiers (jmethodID method, jint * modifiers_ptr)
+    {
+        return funcs->GetMethodModifiers (this, method, modifiers_ptr);
+    }
+
+    jvmtiError GetMaxLocals (jmethodID method, jint * max_ptr)
+    {
+        return funcs->GetMaxLocals (this, method, max_ptr);
+    }
+
+    jvmtiError GetArgumentsSize (jmethodID method, jint * size_ptr)
+    {
+        return funcs->GetArgumentsSize (this, method, size_ptr);
+    }
+
+    jvmtiError GetLineNumberTable (jmethodID method,
+        jint * entry_count_ptr,
+        jvmtiLineNumberEntry ** table_ptr)
+    {
+        return funcs->GetLineNumberTable (this, method, entry_count_ptr,
+            table_ptr);
+    }
+
+    jvmtiError GetMethodLocation (jmethodID method,
+        jlocation * start_location_ptr,
+        jlocation * end_location_ptr)
+    {
+        return funcs->GetMethodLocation (this, method, start_location_ptr,
+            end_location_ptr);
+    }
+
+    jvmtiError GetLocalVariableTable (jmethodID method,
+        jint * entry_count_ptr,
+        jvmtiLocalVariableEntry ** table_ptr)
+    {
+        return funcs->GetLocalVariableTable (this, method, entry_count_ptr,
+            table_ptr);
+    }
+
+    jvmtiError GetBytecodes (jmethodID method,
+        jint * bytecode_count_ptr,
+        unsigned char **bytecodes_ptr)
+    {
+        return funcs->GetBytecodes (this, method, bytecode_count_ptr,
+            bytecodes_ptr);
+    }
+
+    jvmtiError IsMethodNative (jmethodID method, jboolean * is_native_ptr)
+    {
+        return funcs->IsMethodNative (this, method, is_native_ptr);
+    }
+
+    jvmtiError IsMethodSynthetic (jmethodID method, jboolean * is_synthetic_ptr)
+    {
+        return funcs->IsMethodSynthetic (this, method, is_synthetic_ptr);
+    }
+
+    jvmtiError IsMethodObsolete (jmethodID method, jboolean * is_obsolete_ptr)
+    {
+        return funcs->IsMethodObsolete (this, method, is_obsolete_ptr);
+    }
+
+    jvmtiError CreateRawMonitor (const char *name, jrawMonitorID * monitor_ptr)
+    {
+        return funcs->CreateRawMonitor (this, name, monitor_ptr);
+    }
+
+    jvmtiError DestroyRawMonitor (jrawMonitorID monitor)
+    {
+        return funcs->DestroyRawMonitor (this, monitor);
+    }
+
+    jvmtiError RawMonitorEnter (jrawMonitorID monitor)
+    {
+        return funcs->RawMonitorEnter (this, monitor);
+    }
+
+    jvmtiError RawMonitorExit (jrawMonitorID monitor)
+    {
+        return funcs->RawMonitorExit (this, monitor);
+    }
+
+    jvmtiError RawMonitorWait (jrawMonitorID monitor, jlong millis)
+    {
+        return funcs->RawMonitorWait (this, monitor, millis);
+    }
+
+    jvmtiError RawMonitorNotify (jrawMonitorID monitor)
+    {
+        return funcs->RawMonitorNotify (this, monitor);
+    }
+
+    jvmtiError RawMonitorNotifyAll (jrawMonitorID monitor)
+    {
+        return funcs->RawMonitorNotifyAll (this, monitor);
+    }
+
+    jvmtiError SetJNIFunctionTable (const jniNativeInterface * function_table)
+    {
+        return funcs->SetJNIFunctionTable (this, function_table);
+    }
+
+    jvmtiError GetJNIFunctionTable (jniNativeInterface ** function_table)
+    {
+        return funcs->GetJNIFunctionTable (this, function_table);
+    }
+
+    jvmtiError SetEventCallbacks (const jvmtiEventCallbacks * callbacks,
+        jint size_of_callbacks)
+    {
+        return funcs->SetEventCallbacks (this, callbacks, size_of_callbacks);
+    }
+
+    jvmtiError SetEventNotificationMode (jvmtiEventMode mode,
+        jvmtiEvent event_type,
+        jthread event_thread, ...)
+    {
+        return funcs->SetEventNotificationMode (this, mode, event_type,
+            event_thread);
+    }
+
+    jvmtiError GenerateEvents (jvmtiEvent event_type)
+    {
+        return funcs->GenerateEvents (this, event_type);
+    }
+
+    jvmtiError GetExtensionFunctions (jint * extension_count_ptr,
+        jvmtiExtensionFunctionInfo ** extensions)
+    {
+        return funcs->GetExtensionFunctions (this, extension_count_ptr,
+            extensions);
+    }
+
+    jvmtiError GetExtensionEvents (jint * extension_count_ptr,
+        jvmtiExtensionEventInfo ** extensions)
+    {
+        return funcs->GetExtensionEvents (this, extension_count_ptr, extensions);
+    }
+
+    jvmtiError SetExtensionEventCallback (jint extension_event_index,
+        jvmtiExtensionEvent callback)
+    {
+        return funcs->SetExtensionEventCallback (this, extension_event_index,
+            callback);
+    }
+
+    jvmtiError GetPotentialCapabilities (jvmtiCapabilities * capabilities_ptr)
+    {
+        return funcs->GetPotentialCapabilities (this, capabilities_ptr);
+    }
+
+    jvmtiError AddCapabilities (const jvmtiCapabilities * capabilities_ptr)
+    {
+        return funcs->AddCapabilities (this, capabilities_ptr);
+    }
+
+    jvmtiError RelinquishCapabilities (const jvmtiCapabilities *
+        capabilities_ptr)
+    {
+        return funcs->RelinquishCapabilities (this, capabilities_ptr);
+    }
+
+    jvmtiError GetCapabilities (jvmtiCapabilities * capabilities_ptr)
+    {
+        return funcs->GetCapabilities (this, capabilities_ptr);
+    }
+

[... 101 lines stripped ...]


Mime
View raw message