1/*
2 * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /* AUTOMATICALLY GENERATED FILE - DO NOT EDIT */
27
28    /* Include file for the Java(tm) Virtual Machine Tool Interface */
29
30#ifndef _JAVA_JVMTI_H_
31#define _JAVA_JVMTI_H_
32
33#include "jni.h"
34
35#ifdef __cplusplus
36extern "C" {
37#endif
38
39enum {
40    JVMTI_VERSION_1   = 0x30010000,
41    JVMTI_VERSION_1_0 = 0x30010000,
42    JVMTI_VERSION_1_1 = 0x30010100,
43    JVMTI_VERSION_1_2 = 0x30010200,
44    JVMTI_VERSION_9   = 0x30090000,
45
46    JVMTI_VERSION = 0x30000000 + (9 * 0x10000) + (0 * 0x100) + 0  /* version: 9.0.0 */
47};
48
49JNIEXPORT jint JNICALL
50Agent_OnLoad(JavaVM *vm, char *options, void *reserved);
51
52JNIEXPORT jint JNICALL
53Agent_OnAttach(JavaVM* vm, char* options, void* reserved);
54
55JNIEXPORT void JNICALL
56Agent_OnUnload(JavaVM *vm);
57
58    /* Forward declaration of the environment */
59
60struct _jvmtiEnv;
61
62struct jvmtiInterface_1_;
63
64#ifdef __cplusplus
65typedef _jvmtiEnv jvmtiEnv;
66#else
67typedef const struct jvmtiInterface_1_ *jvmtiEnv;
68#endif /* __cplusplus */
69
70/* Derived Base Types */
71
72typedef jobject jthread;
73typedef jobject jthreadGroup;
74typedef jlong jlocation;
75struct _jrawMonitorID;
76typedef struct _jrawMonitorID *jrawMonitorID;
77typedef struct JNINativeInterface_ jniNativeInterface;
78
79    /* Constants */
80
81
82    /* Thread State Flags */
83
84enum {
85    JVMTI_THREAD_STATE_ALIVE = 0x0001,
86    JVMTI_THREAD_STATE_TERMINATED = 0x0002,
87    JVMTI_THREAD_STATE_RUNNABLE = 0x0004,
88    JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400,
89    JVMTI_THREAD_STATE_WAITING = 0x0080,
90    JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010,
91    JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020,
92    JVMTI_THREAD_STATE_SLEEPING = 0x0040,
93    JVMTI_THREAD_STATE_IN_OBJECT_WAIT = 0x0100,
94    JVMTI_THREAD_STATE_PARKED = 0x0200,
95    JVMTI_THREAD_STATE_SUSPENDED = 0x100000,
96    JVMTI_THREAD_STATE_INTERRUPTED = 0x200000,
97    JVMTI_THREAD_STATE_IN_NATIVE = 0x400000,
98    JVMTI_THREAD_STATE_VENDOR_1 = 0x10000000,
99    JVMTI_THREAD_STATE_VENDOR_2 = 0x20000000,
100    JVMTI_THREAD_STATE_VENDOR_3 = 0x40000000
101};
102
103    /* java.lang.Thread.State Conversion Masks */
104
105enum {
106    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,
107    JVMTI_JAVA_LANG_THREAD_STATE_NEW = 0,
108    JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED = JVMTI_THREAD_STATE_TERMINATED,
109    JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE,
110    JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
111    JVMTI_JAVA_LANG_THREAD_STATE_WAITING = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY,
112    JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
113};
114
115    /* Thread Priority Constants */
116
117enum {
118    JVMTI_THREAD_MIN_PRIORITY = 1,
119    JVMTI_THREAD_NORM_PRIORITY = 5,
120    JVMTI_THREAD_MAX_PRIORITY = 10
121};
122
123    /* Heap Filter Flags */
124
125enum {
126    JVMTI_HEAP_FILTER_TAGGED = 0x4,
127    JVMTI_HEAP_FILTER_UNTAGGED = 0x8,
128    JVMTI_HEAP_FILTER_CLASS_TAGGED = 0x10,
129    JVMTI_HEAP_FILTER_CLASS_UNTAGGED = 0x20
130};
131
132    /* Heap Visit Control Flags */
133
134enum {
135    JVMTI_VISIT_OBJECTS = 0x100,
136    JVMTI_VISIT_ABORT = 0x8000
137};
138
139    /* Heap Reference Enumeration */
140
141typedef enum {
142    JVMTI_HEAP_REFERENCE_CLASS = 1,
143    JVMTI_HEAP_REFERENCE_FIELD = 2,
144    JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT = 3,
145    JVMTI_HEAP_REFERENCE_CLASS_LOADER = 4,
146    JVMTI_HEAP_REFERENCE_SIGNERS = 5,
147    JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN = 6,
148    JVMTI_HEAP_REFERENCE_INTERFACE = 7,
149    JVMTI_HEAP_REFERENCE_STATIC_FIELD = 8,
150    JVMTI_HEAP_REFERENCE_CONSTANT_POOL = 9,
151    JVMTI_HEAP_REFERENCE_SUPERCLASS = 10,
152    JVMTI_HEAP_REFERENCE_JNI_GLOBAL = 21,
153    JVMTI_HEAP_REFERENCE_SYSTEM_CLASS = 22,
154    JVMTI_HEAP_REFERENCE_MONITOR = 23,
155    JVMTI_HEAP_REFERENCE_STACK_LOCAL = 24,
156    JVMTI_HEAP_REFERENCE_JNI_LOCAL = 25,
157    JVMTI_HEAP_REFERENCE_THREAD = 26,
158    JVMTI_HEAP_REFERENCE_OTHER = 27
159} jvmtiHeapReferenceKind;
160
161    /* Primitive Type Enumeration */
162
163typedef enum {
164    JVMTI_PRIMITIVE_TYPE_BOOLEAN = 90,
165    JVMTI_PRIMITIVE_TYPE_BYTE = 66,
166    JVMTI_PRIMITIVE_TYPE_CHAR = 67,
167    JVMTI_PRIMITIVE_TYPE_SHORT = 83,
168    JVMTI_PRIMITIVE_TYPE_INT = 73,
169    JVMTI_PRIMITIVE_TYPE_LONG = 74,
170    JVMTI_PRIMITIVE_TYPE_FLOAT = 70,
171    JVMTI_PRIMITIVE_TYPE_DOUBLE = 68
172} jvmtiPrimitiveType;
173
174    /* Heap Object Filter Enumeration */
175
176typedef enum {
177    JVMTI_HEAP_OBJECT_TAGGED = 1,
178    JVMTI_HEAP_OBJECT_UNTAGGED = 2,
179    JVMTI_HEAP_OBJECT_EITHER = 3
180} jvmtiHeapObjectFilter;
181
182    /* Heap Root Kind Enumeration */
183
184typedef enum {
185    JVMTI_HEAP_ROOT_JNI_GLOBAL = 1,
186    JVMTI_HEAP_ROOT_SYSTEM_CLASS = 2,
187    JVMTI_HEAP_ROOT_MONITOR = 3,
188    JVMTI_HEAP_ROOT_STACK_LOCAL = 4,
189    JVMTI_HEAP_ROOT_JNI_LOCAL = 5,
190    JVMTI_HEAP_ROOT_THREAD = 6,
191    JVMTI_HEAP_ROOT_OTHER = 7
192} jvmtiHeapRootKind;
193
194    /* Object Reference Enumeration */
195
196typedef enum {
197    JVMTI_REFERENCE_CLASS = 1,
198    JVMTI_REFERENCE_FIELD = 2,
199    JVMTI_REFERENCE_ARRAY_ELEMENT = 3,
200    JVMTI_REFERENCE_CLASS_LOADER = 4,
201    JVMTI_REFERENCE_SIGNERS = 5,
202    JVMTI_REFERENCE_PROTECTION_DOMAIN = 6,
203    JVMTI_REFERENCE_INTERFACE = 7,
204    JVMTI_REFERENCE_STATIC_FIELD = 8,
205    JVMTI_REFERENCE_CONSTANT_POOL = 9
206} jvmtiObjectReferenceKind;
207
208    /* Iteration Control Enumeration */
209
210typedef enum {
211    JVMTI_ITERATION_CONTINUE = 1,
212    JVMTI_ITERATION_IGNORE = 2,
213    JVMTI_ITERATION_ABORT = 0
214} jvmtiIterationControl;
215
216    /* Class Status Flags */
217
218enum {
219    JVMTI_CLASS_STATUS_VERIFIED = 1,
220    JVMTI_CLASS_STATUS_PREPARED = 2,
221    JVMTI_CLASS_STATUS_INITIALIZED = 4,
222    JVMTI_CLASS_STATUS_ERROR = 8,
223    JVMTI_CLASS_STATUS_ARRAY = 16,
224    JVMTI_CLASS_STATUS_PRIMITIVE = 32
225};
226
227    /* Event Enable/Disable */
228
229typedef enum {
230    JVMTI_ENABLE = 1,
231    JVMTI_DISABLE = 0
232} jvmtiEventMode;
233
234    /* Extension Function/Event Parameter Types */
235
236typedef enum {
237    JVMTI_TYPE_JBYTE = 101,
238    JVMTI_TYPE_JCHAR = 102,
239    JVMTI_TYPE_JSHORT = 103,
240    JVMTI_TYPE_JINT = 104,
241    JVMTI_TYPE_JLONG = 105,
242    JVMTI_TYPE_JFLOAT = 106,
243    JVMTI_TYPE_JDOUBLE = 107,
244    JVMTI_TYPE_JBOOLEAN = 108,
245    JVMTI_TYPE_JOBJECT = 109,
246    JVMTI_TYPE_JTHREAD = 110,
247    JVMTI_TYPE_JCLASS = 111,
248    JVMTI_TYPE_JVALUE = 112,
249    JVMTI_TYPE_JFIELDID = 113,
250    JVMTI_TYPE_JMETHODID = 114,
251    JVMTI_TYPE_CCHAR = 115,
252    JVMTI_TYPE_CVOID = 116,
253    JVMTI_TYPE_JNIENV = 117
254} jvmtiParamTypes;
255
256    /* Extension Function/Event Parameter Kinds */
257
258typedef enum {
259    JVMTI_KIND_IN = 91,
260    JVMTI_KIND_IN_PTR = 92,
261    JVMTI_KIND_IN_BUF = 93,
262    JVMTI_KIND_ALLOC_BUF = 94,
263    JVMTI_KIND_ALLOC_ALLOC_BUF = 95,
264    JVMTI_KIND_OUT = 96,
265    JVMTI_KIND_OUT_BUF = 97
266} jvmtiParamKind;
267
268    /* Timer Kinds */
269
270typedef enum {
271    JVMTI_TIMER_USER_CPU = 30,
272    JVMTI_TIMER_TOTAL_CPU = 31,
273    JVMTI_TIMER_ELAPSED = 32
274} jvmtiTimerKind;
275
276    /* Phases of execution */
277
278typedef enum {
279    JVMTI_PHASE_ONLOAD = 1,
280    JVMTI_PHASE_PRIMORDIAL = 2,
281    JVMTI_PHASE_START = 6,
282    JVMTI_PHASE_LIVE = 4,
283    JVMTI_PHASE_DEAD = 8
284} jvmtiPhase;
285
286    /* Version Interface Types */
287
288enum {
289    JVMTI_VERSION_INTERFACE_JNI = 0x00000000,
290    JVMTI_VERSION_INTERFACE_JVMTI = 0x30000000
291};
292
293    /* Version Masks */
294
295enum {
296    JVMTI_VERSION_MASK_INTERFACE_TYPE = 0x70000000,
297    JVMTI_VERSION_MASK_MAJOR = 0x0FFF0000,
298    JVMTI_VERSION_MASK_MINOR = 0x0000FF00,
299    JVMTI_VERSION_MASK_MICRO = 0x000000FF
300};
301
302    /* Version Shifts */
303
304enum {
305    JVMTI_VERSION_SHIFT_MAJOR = 16,
306    JVMTI_VERSION_SHIFT_MINOR = 8,
307    JVMTI_VERSION_SHIFT_MICRO = 0
308};
309
310    /* Verbose Flag Enumeration */
311
312typedef enum {
313    JVMTI_VERBOSE_OTHER = 0,
314    JVMTI_VERBOSE_GC = 1,
315    JVMTI_VERBOSE_CLASS = 2,
316    JVMTI_VERBOSE_JNI = 4
317} jvmtiVerboseFlag;
318
319    /* JLocation Format Enumeration */
320
321typedef enum {
322    JVMTI_JLOCATION_JVMBCI = 1,
323    JVMTI_JLOCATION_MACHINEPC = 2,
324    JVMTI_JLOCATION_OTHER = 0
325} jvmtiJlocationFormat;
326
327    /* Resource Exhaustion Flags */
328
329enum {
330    JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR = 0x0001,
331    JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP = 0x0002,
332    JVMTI_RESOURCE_EXHAUSTED_THREADS = 0x0004
333};
334
335    /* Errors */
336
337typedef enum {
338    JVMTI_ERROR_NONE = 0,
339    JVMTI_ERROR_INVALID_THREAD = 10,
340    JVMTI_ERROR_INVALID_THREAD_GROUP = 11,
341    JVMTI_ERROR_INVALID_PRIORITY = 12,
342    JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13,
343    JVMTI_ERROR_THREAD_SUSPENDED = 14,
344    JVMTI_ERROR_THREAD_NOT_ALIVE = 15,
345    JVMTI_ERROR_INVALID_OBJECT = 20,
346    JVMTI_ERROR_INVALID_CLASS = 21,
347    JVMTI_ERROR_CLASS_NOT_PREPARED = 22,
348    JVMTI_ERROR_INVALID_METHODID = 23,
349    JVMTI_ERROR_INVALID_LOCATION = 24,
350    JVMTI_ERROR_INVALID_FIELDID = 25,
351    JVMTI_ERROR_INVALID_MODULE = 26,
352    JVMTI_ERROR_NO_MORE_FRAMES = 31,
353    JVMTI_ERROR_OPAQUE_FRAME = 32,
354    JVMTI_ERROR_TYPE_MISMATCH = 34,
355    JVMTI_ERROR_INVALID_SLOT = 35,
356    JVMTI_ERROR_DUPLICATE = 40,
357    JVMTI_ERROR_NOT_FOUND = 41,
358    JVMTI_ERROR_INVALID_MONITOR = 50,
359    JVMTI_ERROR_NOT_MONITOR_OWNER = 51,
360    JVMTI_ERROR_INTERRUPT = 52,
361    JVMTI_ERROR_INVALID_CLASS_FORMAT = 60,
362    JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61,
363    JVMTI_ERROR_FAILS_VERIFICATION = 62,
364    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63,
365    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64,
366    JVMTI_ERROR_INVALID_TYPESTATE = 65,
367    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66,
368    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67,
369    JVMTI_ERROR_UNSUPPORTED_VERSION = 68,
370    JVMTI_ERROR_NAMES_DONT_MATCH = 69,
371    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70,
372    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71,
373    JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
374    JVMTI_ERROR_UNMODIFIABLE_MODULE = 80,
375    JVMTI_ERROR_NOT_AVAILABLE = 98,
376    JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99,
377    JVMTI_ERROR_NULL_POINTER = 100,
378    JVMTI_ERROR_ABSENT_INFORMATION = 101,
379    JVMTI_ERROR_INVALID_EVENT_TYPE = 102,
380    JVMTI_ERROR_ILLEGAL_ARGUMENT = 103,
381    JVMTI_ERROR_NATIVE_METHOD = 104,
382    JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED = 106,
383    JVMTI_ERROR_OUT_OF_MEMORY = 110,
384    JVMTI_ERROR_ACCESS_DENIED = 111,
385    JVMTI_ERROR_WRONG_PHASE = 112,
386    JVMTI_ERROR_INTERNAL = 113,
387    JVMTI_ERROR_UNATTACHED_THREAD = 115,
388    JVMTI_ERROR_INVALID_ENVIRONMENT = 116,
389    JVMTI_ERROR_MAX = 116
390} jvmtiError;
391
392    /* Event IDs */
393
394typedef enum {
395    JVMTI_MIN_EVENT_TYPE_VAL = 50,
396    JVMTI_EVENT_VM_INIT = 50,
397    JVMTI_EVENT_VM_DEATH = 51,
398    JVMTI_EVENT_THREAD_START = 52,
399    JVMTI_EVENT_THREAD_END = 53,
400    JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54,
401    JVMTI_EVENT_CLASS_LOAD = 55,
402    JVMTI_EVENT_CLASS_PREPARE = 56,
403    JVMTI_EVENT_VM_START = 57,
404    JVMTI_EVENT_EXCEPTION = 58,
405    JVMTI_EVENT_EXCEPTION_CATCH = 59,
406    JVMTI_EVENT_SINGLE_STEP = 60,
407    JVMTI_EVENT_FRAME_POP = 61,
408    JVMTI_EVENT_BREAKPOINT = 62,
409    JVMTI_EVENT_FIELD_ACCESS = 63,
410    JVMTI_EVENT_FIELD_MODIFICATION = 64,
411    JVMTI_EVENT_METHOD_ENTRY = 65,
412    JVMTI_EVENT_METHOD_EXIT = 66,
413    JVMTI_EVENT_NATIVE_METHOD_BIND = 67,
414    JVMTI_EVENT_COMPILED_METHOD_LOAD = 68,
415    JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69,
416    JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70,
417    JVMTI_EVENT_DATA_DUMP_REQUEST = 71,
418    JVMTI_EVENT_MONITOR_WAIT = 73,
419    JVMTI_EVENT_MONITOR_WAITED = 74,
420    JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75,
421    JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76,
422    JVMTI_EVENT_RESOURCE_EXHAUSTED = 80,
423    JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
424    JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
425    JVMTI_EVENT_OBJECT_FREE = 83,
426    JVMTI_EVENT_VM_OBJECT_ALLOC = 84,
427    JVMTI_MAX_EVENT_TYPE_VAL = 84
428} jvmtiEvent;
429
430
431    /* Pre-Declarations */
432struct _jvmtiThreadInfo;
433typedef struct _jvmtiThreadInfo jvmtiThreadInfo;
434struct _jvmtiMonitorStackDepthInfo;
435typedef struct _jvmtiMonitorStackDepthInfo jvmtiMonitorStackDepthInfo;
436struct _jvmtiThreadGroupInfo;
437typedef struct _jvmtiThreadGroupInfo jvmtiThreadGroupInfo;
438struct _jvmtiFrameInfo;
439typedef struct _jvmtiFrameInfo jvmtiFrameInfo;
440struct _jvmtiStackInfo;
441typedef struct _jvmtiStackInfo jvmtiStackInfo;
442struct _jvmtiHeapReferenceInfoField;
443typedef struct _jvmtiHeapReferenceInfoField jvmtiHeapReferenceInfoField;
444struct _jvmtiHeapReferenceInfoArray;
445typedef struct _jvmtiHeapReferenceInfoArray jvmtiHeapReferenceInfoArray;
446struct _jvmtiHeapReferenceInfoConstantPool;
447typedef struct _jvmtiHeapReferenceInfoConstantPool jvmtiHeapReferenceInfoConstantPool;
448struct _jvmtiHeapReferenceInfoStackLocal;
449typedef struct _jvmtiHeapReferenceInfoStackLocal jvmtiHeapReferenceInfoStackLocal;
450struct _jvmtiHeapReferenceInfoJniLocal;
451typedef struct _jvmtiHeapReferenceInfoJniLocal jvmtiHeapReferenceInfoJniLocal;
452struct _jvmtiHeapReferenceInfoReserved;
453typedef struct _jvmtiHeapReferenceInfoReserved jvmtiHeapReferenceInfoReserved;
454union _jvmtiHeapReferenceInfo;
455typedef union _jvmtiHeapReferenceInfo jvmtiHeapReferenceInfo;
456struct _jvmtiHeapCallbacks;
457typedef struct _jvmtiHeapCallbacks jvmtiHeapCallbacks;
458struct _jvmtiClassDefinition;
459typedef struct _jvmtiClassDefinition jvmtiClassDefinition;
460struct _jvmtiMonitorUsage;
461typedef struct _jvmtiMonitorUsage jvmtiMonitorUsage;
462struct _jvmtiLineNumberEntry;
463typedef struct _jvmtiLineNumberEntry jvmtiLineNumberEntry;
464struct _jvmtiLocalVariableEntry;
465typedef struct _jvmtiLocalVariableEntry jvmtiLocalVariableEntry;
466struct _jvmtiParamInfo;
467typedef struct _jvmtiParamInfo jvmtiParamInfo;
468struct _jvmtiExtensionFunctionInfo;
469typedef struct _jvmtiExtensionFunctionInfo jvmtiExtensionFunctionInfo;
470struct _jvmtiExtensionEventInfo;
471typedef struct _jvmtiExtensionEventInfo jvmtiExtensionEventInfo;
472struct _jvmtiTimerInfo;
473typedef struct _jvmtiTimerInfo jvmtiTimerInfo;
474struct _jvmtiAddrLocationMap;
475typedef struct _jvmtiAddrLocationMap jvmtiAddrLocationMap;
476
477    /* Function Types */
478
479typedef void (JNICALL *jvmtiStartFunction)
480    (jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg);
481
482typedef jint (JNICALL *jvmtiHeapIterationCallback)
483    (jlong class_tag, jlong size, jlong* tag_ptr, jint length, void* user_data);
484
485typedef jint (JNICALL *jvmtiHeapReferenceCallback)
486    (jvmtiHeapReferenceKind reference_kind, const jvmtiHeapReferenceInfo* reference_info, jlong class_tag, jlong referrer_class_tag, jlong size, jlong* tag_ptr, jlong* referrer_tag_ptr, jint length, void* user_data);
487
488typedef jint (JNICALL *jvmtiPrimitiveFieldCallback)
489    (jvmtiHeapReferenceKind kind, const jvmtiHeapReferenceInfo* info, jlong object_class_tag, jlong* object_tag_ptr, jvalue value, jvmtiPrimitiveType value_type, void* user_data);
490
491typedef jint (JNICALL *jvmtiArrayPrimitiveValueCallback)
492    (jlong class_tag, jlong size, jlong* tag_ptr, jint element_count, jvmtiPrimitiveType element_type, const void* elements, void* user_data);
493
494typedef jint (JNICALL *jvmtiStringPrimitiveValueCallback)
495    (jlong class_tag, jlong size, jlong* tag_ptr, const jchar* value, jint value_length, void* user_data);
496
497typedef jint (JNICALL *jvmtiReservedCallback)
498    ();
499
500typedef jvmtiIterationControl (JNICALL *jvmtiHeapObjectCallback)
501    (jlong class_tag, jlong size, jlong* tag_ptr, void* user_data);
502
503typedef jvmtiIterationControl (JNICALL *jvmtiHeapRootCallback)
504    (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, void* user_data);
505
506typedef jvmtiIterationControl (JNICALL *jvmtiStackReferenceCallback)
507    (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong thread_tag, jint depth, jmethodID method, jint slot, void* user_data);
508
509typedef jvmtiIterationControl (JNICALL *jvmtiObjectReferenceCallback)
510    (jvmtiObjectReferenceKind reference_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong referrer_tag, jint referrer_index, void* user_data);
511
512typedef jvmtiError (JNICALL *jvmtiExtensionFunction)
513    (jvmtiEnv* jvmti_env,  ...);
514
515typedef void (JNICALL *jvmtiExtensionEvent)
516    (jvmtiEnv* jvmti_env,  ...);
517
518
519    /* Structure Types */
520struct _jvmtiThreadInfo {
521    char* name;
522    jint priority;
523    jboolean is_daemon;
524    jthreadGroup thread_group;
525    jobject context_class_loader;
526};
527struct _jvmtiMonitorStackDepthInfo {
528    jobject monitor;
529    jint stack_depth;
530};
531struct _jvmtiThreadGroupInfo {
532    jthreadGroup parent;
533    char* name;
534    jint max_priority;
535    jboolean is_daemon;
536};
537struct _jvmtiFrameInfo {
538    jmethodID method;
539    jlocation location;
540};
541struct _jvmtiStackInfo {
542    jthread thread;
543    jint state;
544    jvmtiFrameInfo* frame_buffer;
545    jint frame_count;
546};
547struct _jvmtiHeapReferenceInfoField {
548    jint index;
549};
550struct _jvmtiHeapReferenceInfoArray {
551    jint index;
552};
553struct _jvmtiHeapReferenceInfoConstantPool {
554    jint index;
555};
556struct _jvmtiHeapReferenceInfoStackLocal {
557    jlong thread_tag;
558    jlong thread_id;
559    jint depth;
560    jmethodID method;
561    jlocation location;
562    jint slot;
563};
564struct _jvmtiHeapReferenceInfoJniLocal {
565    jlong thread_tag;
566    jlong thread_id;
567    jint depth;
568    jmethodID method;
569};
570struct _jvmtiHeapReferenceInfoReserved {
571    jlong reserved1;
572    jlong reserved2;
573    jlong reserved3;
574    jlong reserved4;
575    jlong reserved5;
576    jlong reserved6;
577    jlong reserved7;
578    jlong reserved8;
579};
580union _jvmtiHeapReferenceInfo {
581    jvmtiHeapReferenceInfoField field;
582    jvmtiHeapReferenceInfoArray array;
583    jvmtiHeapReferenceInfoConstantPool constant_pool;
584    jvmtiHeapReferenceInfoStackLocal stack_local;
585    jvmtiHeapReferenceInfoJniLocal jni_local;
586    jvmtiHeapReferenceInfoReserved other;
587};
588struct _jvmtiHeapCallbacks {
589    jvmtiHeapIterationCallback heap_iteration_callback;
590    jvmtiHeapReferenceCallback heap_reference_callback;
591    jvmtiPrimitiveFieldCallback primitive_field_callback;
592    jvmtiArrayPrimitiveValueCallback array_primitive_value_callback;
593    jvmtiStringPrimitiveValueCallback string_primitive_value_callback;
594    jvmtiReservedCallback reserved5;
595    jvmtiReservedCallback reserved6;
596    jvmtiReservedCallback reserved7;
597    jvmtiReservedCallback reserved8;
598    jvmtiReservedCallback reserved9;
599    jvmtiReservedCallback reserved10;
600    jvmtiReservedCallback reserved11;
601    jvmtiReservedCallback reserved12;
602    jvmtiReservedCallback reserved13;
603    jvmtiReservedCallback reserved14;
604    jvmtiReservedCallback reserved15;
605};
606struct _jvmtiClassDefinition {
607    jclass klass;
608    jint class_byte_count;
609    const unsigned char* class_bytes;
610};
611struct _jvmtiMonitorUsage {
612    jthread owner;
613    jint entry_count;
614    jint waiter_count;
615    jthread* waiters;
616    jint notify_waiter_count;
617    jthread* notify_waiters;
618};
619struct _jvmtiLineNumberEntry {
620    jlocation start_location;
621    jint line_number;
622};
623struct _jvmtiLocalVariableEntry {
624    jlocation start_location;
625    jint length;
626    char* name;
627    char* signature;
628    char* generic_signature;
629    jint slot;
630};
631struct _jvmtiParamInfo {
632    char* name;
633    jvmtiParamKind kind;
634    jvmtiParamTypes base_type;
635    jboolean null_ok;
636};
637struct _jvmtiExtensionFunctionInfo {
638    jvmtiExtensionFunction func;
639    char* id;
640    char* short_description;
641    jint param_count;
642    jvmtiParamInfo* params;
643    jint error_count;
644    jvmtiError* errors;
645};
646struct _jvmtiExtensionEventInfo {
647    jint extension_event_index;
648    char* id;
649    char* short_description;
650    jint param_count;
651    jvmtiParamInfo* params;
652};
653struct _jvmtiTimerInfo {
654    jlong max_value;
655    jboolean may_skip_forward;
656    jboolean may_skip_backward;
657    jvmtiTimerKind kind;
658    jlong reserved1;
659    jlong reserved2;
660};
661struct _jvmtiAddrLocationMap {
662    const void* start_address;
663    jlocation location;
664};
665
666typedef struct {
667    unsigned int can_tag_objects : 1;
668    unsigned int can_generate_field_modification_events : 1;
669    unsigned int can_generate_field_access_events : 1;
670    unsigned int can_get_bytecodes : 1;
671    unsigned int can_get_synthetic_attribute : 1;
672    unsigned int can_get_owned_monitor_info : 1;
673    unsigned int can_get_current_contended_monitor : 1;
674    unsigned int can_get_monitor_info : 1;
675    unsigned int can_pop_frame : 1;
676    unsigned int can_redefine_classes : 1;
677    unsigned int can_signal_thread : 1;
678    unsigned int can_get_source_file_name : 1;
679    unsigned int can_get_line_numbers : 1;
680    unsigned int can_get_source_debug_extension : 1;
681    unsigned int can_access_local_variables : 1;
682    unsigned int can_maintain_original_method_order : 1;
683    unsigned int can_generate_single_step_events : 1;
684    unsigned int can_generate_exception_events : 1;
685    unsigned int can_generate_frame_pop_events : 1;
686    unsigned int can_generate_breakpoint_events : 1;
687    unsigned int can_suspend : 1;
688    unsigned int can_redefine_any_class : 1;
689    unsigned int can_get_current_thread_cpu_time : 1;
690    unsigned int can_get_thread_cpu_time : 1;
691    unsigned int can_generate_method_entry_events : 1;
692    unsigned int can_generate_method_exit_events : 1;
693    unsigned int can_generate_all_class_hook_events : 1;
694    unsigned int can_generate_compiled_method_load_events : 1;
695    unsigned int can_generate_monitor_events : 1;
696    unsigned int can_generate_vm_object_alloc_events : 1;
697    unsigned int can_generate_native_method_bind_events : 1;
698    unsigned int can_generate_garbage_collection_events : 1;
699    unsigned int can_generate_object_free_events : 1;
700    unsigned int can_force_early_return : 1;
701    unsigned int can_get_owned_monitor_stack_depth_info : 1;
702    unsigned int can_get_constant_pool : 1;
703    unsigned int can_set_native_method_prefix : 1;
704    unsigned int can_retransform_classes : 1;
705    unsigned int can_retransform_any_class : 1;
706    unsigned int can_generate_resource_exhaustion_heap_events : 1;
707    unsigned int can_generate_resource_exhaustion_threads_events : 1;
708    unsigned int can_generate_early_vmstart : 1;
709    unsigned int can_generate_early_class_hook_events : 1;
710    unsigned int : 5;
711    unsigned int : 16;
712    unsigned int : 16;
713    unsigned int : 16;
714    unsigned int : 16;
715    unsigned int : 16;
716} jvmtiCapabilities;
717
718
719    /* Event Definitions */
720
721typedef void (JNICALL *jvmtiEventReserved)(void);
722
723
724typedef void (JNICALL *jvmtiEventBreakpoint)
725    (jvmtiEnv *jvmti_env,
726     JNIEnv* jni_env,
727     jthread thread,
728     jmethodID method,
729     jlocation location);
730
731typedef void (JNICALL *jvmtiEventClassFileLoadHook)
732    (jvmtiEnv *jvmti_env,
733     JNIEnv* jni_env,
734     jclass class_being_redefined,
735     jobject loader,
736     const char* name,
737     jobject protection_domain,
738     jint class_data_len,
739     const unsigned char* class_data,
740     jint* new_class_data_len,
741     unsigned char** new_class_data);
742
743typedef void (JNICALL *jvmtiEventClassLoad)
744    (jvmtiEnv *jvmti_env,
745     JNIEnv* jni_env,
746     jthread thread,
747     jclass klass);
748
749typedef void (JNICALL *jvmtiEventClassPrepare)
750    (jvmtiEnv *jvmti_env,
751     JNIEnv* jni_env,
752     jthread thread,
753     jclass klass);
754
755typedef void (JNICALL *jvmtiEventCompiledMethodLoad)
756    (jvmtiEnv *jvmti_env,
757     jmethodID method,
758     jint code_size,
759     const void* code_addr,
760     jint map_length,
761     const jvmtiAddrLocationMap* map,
762     const void* compile_info);
763
764typedef void (JNICALL *jvmtiEventCompiledMethodUnload)
765    (jvmtiEnv *jvmti_env,
766     jmethodID method,
767     const void* code_addr);
768
769typedef void (JNICALL *jvmtiEventDataDumpRequest)
770    (jvmtiEnv *jvmti_env);
771
772typedef void (JNICALL *jvmtiEventDynamicCodeGenerated)
773    (jvmtiEnv *jvmti_env,
774     const char* name,
775     const void* address,
776     jint length);
777
778typedef void (JNICALL *jvmtiEventException)
779    (jvmtiEnv *jvmti_env,
780     JNIEnv* jni_env,
781     jthread thread,
782     jmethodID method,
783     jlocation location,
784     jobject exception,
785     jmethodID catch_method,
786     jlocation catch_location);
787
788typedef void (JNICALL *jvmtiEventExceptionCatch)
789    (jvmtiEnv *jvmti_env,
790     JNIEnv* jni_env,
791     jthread thread,
792     jmethodID method,
793     jlocation location,
794     jobject exception);
795
796typedef void (JNICALL *jvmtiEventFieldAccess)
797    (jvmtiEnv *jvmti_env,
798     JNIEnv* jni_env,
799     jthread thread,
800     jmethodID method,
801     jlocation location,
802     jclass field_klass,
803     jobject object,
804     jfieldID field);
805
806typedef void (JNICALL *jvmtiEventFieldModification)
807    (jvmtiEnv *jvmti_env,
808     JNIEnv* jni_env,
809     jthread thread,
810     jmethodID method,
811     jlocation location,
812     jclass field_klass,
813     jobject object,
814     jfieldID field,
815     char signature_type,
816     jvalue new_value);
817
818typedef void (JNICALL *jvmtiEventFramePop)
819    (jvmtiEnv *jvmti_env,
820     JNIEnv* jni_env,
821     jthread thread,
822     jmethodID method,
823     jboolean was_popped_by_exception);
824
825typedef void (JNICALL *jvmtiEventGarbageCollectionFinish)
826    (jvmtiEnv *jvmti_env);
827
828typedef void (JNICALL *jvmtiEventGarbageCollectionStart)
829    (jvmtiEnv *jvmti_env);
830
831typedef void (JNICALL *jvmtiEventMethodEntry)
832    (jvmtiEnv *jvmti_env,
833     JNIEnv* jni_env,
834     jthread thread,
835     jmethodID method);
836
837typedef void (JNICALL *jvmtiEventMethodExit)
838    (jvmtiEnv *jvmti_env,
839     JNIEnv* jni_env,
840     jthread thread,
841     jmethodID method,
842     jboolean was_popped_by_exception,
843     jvalue return_value);
844
845typedef void (JNICALL *jvmtiEventMonitorContendedEnter)
846    (jvmtiEnv *jvmti_env,
847     JNIEnv* jni_env,
848     jthread thread,
849     jobject object);
850
851typedef void (JNICALL *jvmtiEventMonitorContendedEntered)
852    (jvmtiEnv *jvmti_env,
853     JNIEnv* jni_env,
854     jthread thread,
855     jobject object);
856
857typedef void (JNICALL *jvmtiEventMonitorWait)
858    (jvmtiEnv *jvmti_env,
859     JNIEnv* jni_env,
860     jthread thread,
861     jobject object,
862     jlong timeout);
863
864typedef void (JNICALL *jvmtiEventMonitorWaited)
865    (jvmtiEnv *jvmti_env,
866     JNIEnv* jni_env,
867     jthread thread,
868     jobject object,
869     jboolean timed_out);
870
871typedef void (JNICALL *jvmtiEventNativeMethodBind)
872    (jvmtiEnv *jvmti_env,
873     JNIEnv* jni_env,
874     jthread thread,
875     jmethodID method,
876     void* address,
877     void** new_address_ptr);
878
879typedef void (JNICALL *jvmtiEventObjectFree)
880    (jvmtiEnv *jvmti_env,
881     jlong tag);
882
883typedef void (JNICALL *jvmtiEventResourceExhausted)
884    (jvmtiEnv *jvmti_env,
885     JNIEnv* jni_env,
886     jint flags,
887     const void* reserved,
888     const char* description);
889
890typedef void (JNICALL *jvmtiEventSingleStep)
891    (jvmtiEnv *jvmti_env,
892     JNIEnv* jni_env,
893     jthread thread,
894     jmethodID method,
895     jlocation location);
896
897typedef void (JNICALL *jvmtiEventThreadEnd)
898    (jvmtiEnv *jvmti_env,
899     JNIEnv* jni_env,
900     jthread thread);
901
902typedef void (JNICALL *jvmtiEventThreadStart)
903    (jvmtiEnv *jvmti_env,
904     JNIEnv* jni_env,
905     jthread thread);
906
907typedef void (JNICALL *jvmtiEventVMDeath)
908    (jvmtiEnv *jvmti_env,
909     JNIEnv* jni_env);
910
911typedef void (JNICALL *jvmtiEventVMInit)
912    (jvmtiEnv *jvmti_env,
913     JNIEnv* jni_env,
914     jthread thread);
915
916typedef void (JNICALL *jvmtiEventVMObjectAlloc)
917    (jvmtiEnv *jvmti_env,
918     JNIEnv* jni_env,
919     jthread thread,
920     jobject object,
921     jclass object_klass,
922     jlong size);
923
924typedef void (JNICALL *jvmtiEventVMStart)
925    (jvmtiEnv *jvmti_env,
926     JNIEnv* jni_env);
927
928    /* Event Callback Structure */
929
930typedef struct {
931                              /*   50 : VM Initialization Event */
932    jvmtiEventVMInit VMInit;
933                              /*   51 : VM Death Event */
934    jvmtiEventVMDeath VMDeath;
935                              /*   52 : Thread Start */
936    jvmtiEventThreadStart ThreadStart;
937                              /*   53 : Thread End */
938    jvmtiEventThreadEnd ThreadEnd;
939                              /*   54 : Class File Load Hook */
940    jvmtiEventClassFileLoadHook ClassFileLoadHook;
941                              /*   55 : Class Load */
942    jvmtiEventClassLoad ClassLoad;
943                              /*   56 : Class Prepare */
944    jvmtiEventClassPrepare ClassPrepare;
945                              /*   57 : VM Start Event */
946    jvmtiEventVMStart VMStart;
947                              /*   58 : Exception */
948    jvmtiEventException Exception;
949                              /*   59 : Exception Catch */
950    jvmtiEventExceptionCatch ExceptionCatch;
951                              /*   60 : Single Step */
952    jvmtiEventSingleStep SingleStep;
953                              /*   61 : Frame Pop */
954    jvmtiEventFramePop FramePop;
955                              /*   62 : Breakpoint */
956    jvmtiEventBreakpoint Breakpoint;
957                              /*   63 : Field Access */
958    jvmtiEventFieldAccess FieldAccess;
959                              /*   64 : Field Modification */
960    jvmtiEventFieldModification FieldModification;
961                              /*   65 : Method Entry */
962    jvmtiEventMethodEntry MethodEntry;
963                              /*   66 : Method Exit */
964    jvmtiEventMethodExit MethodExit;
965                              /*   67 : Native Method Bind */
966    jvmtiEventNativeMethodBind NativeMethodBind;
967                              /*   68 : Compiled Method Load */
968    jvmtiEventCompiledMethodLoad CompiledMethodLoad;
969                              /*   69 : Compiled Method Unload */
970    jvmtiEventCompiledMethodUnload CompiledMethodUnload;
971                              /*   70 : Dynamic Code Generated */
972    jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
973                              /*   71 : Data Dump Request */
974    jvmtiEventDataDumpRequest DataDumpRequest;
975                              /*   72 */
976    jvmtiEventReserved reserved72;
977                              /*   73 : Monitor Wait */
978    jvmtiEventMonitorWait MonitorWait;
979                              /*   74 : Monitor Waited */
980    jvmtiEventMonitorWaited MonitorWaited;
981                              /*   75 : Monitor Contended Enter */
982    jvmtiEventMonitorContendedEnter MonitorContendedEnter;
983                              /*   76 : Monitor Contended Entered */
984    jvmtiEventMonitorContendedEntered MonitorContendedEntered;
985                              /*   77 */
986    jvmtiEventReserved reserved77;
987                              /*   78 */
988    jvmtiEventReserved reserved78;
989                              /*   79 */
990    jvmtiEventReserved reserved79;
991                              /*   80 : Resource Exhausted */
992    jvmtiEventResourceExhausted ResourceExhausted;
993                              /*   81 : Garbage Collection Start */
994    jvmtiEventGarbageCollectionStart GarbageCollectionStart;
995                              /*   82 : Garbage Collection Finish */
996    jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
997                              /*   83 : Object Free */
998    jvmtiEventObjectFree ObjectFree;
999                              /*   84 : VM Object Allocation */
1000    jvmtiEventVMObjectAlloc VMObjectAlloc;
1001} jvmtiEventCallbacks;
1002
1003
1004    /* Function Interface */
1005
1006typedef struct jvmtiInterface_1_ {
1007
1008  /*   1 :  RESERVED */
1009  void *reserved1;
1010
1011  /*   2 : Set Event Notification Mode */
1012  jvmtiError (JNICALL *SetEventNotificationMode) (jvmtiEnv* env,
1013    jvmtiEventMode mode,
1014    jvmtiEvent event_type,
1015    jthread event_thread,
1016     ...);
1017
1018  /*   3 : Get All Modules */
1019  jvmtiError (JNICALL *GetAllModules) (jvmtiEnv* env,
1020    jint* module_count_ptr,
1021    jobject** modules_ptr);
1022
1023  /*   4 : Get All Threads */
1024  jvmtiError (JNICALL *GetAllThreads) (jvmtiEnv* env,
1025    jint* threads_count_ptr,
1026    jthread** threads_ptr);
1027
1028  /*   5 : Suspend Thread */
1029  jvmtiError (JNICALL *SuspendThread) (jvmtiEnv* env,
1030    jthread thread);
1031
1032  /*   6 : Resume Thread */
1033  jvmtiError (JNICALL *ResumeThread) (jvmtiEnv* env,
1034    jthread thread);
1035
1036  /*   7 : Stop Thread */
1037  jvmtiError (JNICALL *StopThread) (jvmtiEnv* env,
1038    jthread thread,
1039    jobject exception);
1040
1041  /*   8 : Interrupt Thread */
1042  jvmtiError (JNICALL *InterruptThread) (jvmtiEnv* env,
1043    jthread thread);
1044
1045  /*   9 : Get Thread Info */
1046  jvmtiError (JNICALL *GetThreadInfo) (jvmtiEnv* env,
1047    jthread thread,
1048    jvmtiThreadInfo* info_ptr);
1049
1050  /*   10 : Get Owned Monitor Info */
1051  jvmtiError (JNICALL *GetOwnedMonitorInfo) (jvmtiEnv* env,
1052    jthread thread,
1053    jint* owned_monitor_count_ptr,
1054    jobject** owned_monitors_ptr);
1055
1056  /*   11 : Get Current Contended Monitor */
1057  jvmtiError (JNICALL *GetCurrentContendedMonitor) (jvmtiEnv* env,
1058    jthread thread,
1059    jobject* monitor_ptr);
1060
1061  /*   12 : Run Agent Thread */
1062  jvmtiError (JNICALL *RunAgentThread) (jvmtiEnv* env,
1063    jthread thread,
1064    jvmtiStartFunction proc,
1065    const void* arg,
1066    jint priority);
1067
1068  /*   13 : Get Top Thread Groups */
1069  jvmtiError (JNICALL *GetTopThreadGroups) (jvmtiEnv* env,
1070    jint* group_count_ptr,
1071    jthreadGroup** groups_ptr);
1072
1073  /*   14 : Get Thread Group Info */
1074  jvmtiError (JNICALL *GetThreadGroupInfo) (jvmtiEnv* env,
1075    jthreadGroup group,
1076    jvmtiThreadGroupInfo* info_ptr);
1077
1078  /*   15 : Get Thread Group Children */
1079  jvmtiError (JNICALL *GetThreadGroupChildren) (jvmtiEnv* env,
1080    jthreadGroup group,
1081    jint* thread_count_ptr,
1082    jthread** threads_ptr,
1083    jint* group_count_ptr,
1084    jthreadGroup** groups_ptr);
1085
1086  /*   16 : Get Frame Count */
1087  jvmtiError (JNICALL *GetFrameCount) (jvmtiEnv* env,
1088    jthread thread,
1089    jint* count_ptr);
1090
1091  /*   17 : Get Thread State */
1092  jvmtiError (JNICALL *GetThreadState) (jvmtiEnv* env,
1093    jthread thread,
1094    jint* thread_state_ptr);
1095
1096  /*   18 : Get Current Thread */
1097  jvmtiError (JNICALL *GetCurrentThread) (jvmtiEnv* env,
1098    jthread* thread_ptr);
1099
1100  /*   19 : Get Frame Location */
1101  jvmtiError (JNICALL *GetFrameLocation) (jvmtiEnv* env,
1102    jthread thread,
1103    jint depth,
1104    jmethodID* method_ptr,
1105    jlocation* location_ptr);
1106
1107  /*   20 : Notify Frame Pop */
1108  jvmtiError (JNICALL *NotifyFramePop) (jvmtiEnv* env,
1109    jthread thread,
1110    jint depth);
1111
1112  /*   21 : Get Local Variable - Object */
1113  jvmtiError (JNICALL *GetLocalObject) (jvmtiEnv* env,
1114    jthread thread,
1115    jint depth,
1116    jint slot,
1117    jobject* value_ptr);
1118
1119  /*   22 : Get Local Variable - Int */
1120  jvmtiError (JNICALL *GetLocalInt) (jvmtiEnv* env,
1121    jthread thread,
1122    jint depth,
1123    jint slot,
1124    jint* value_ptr);
1125
1126  /*   23 : Get Local Variable - Long */
1127  jvmtiError (JNICALL *GetLocalLong) (jvmtiEnv* env,
1128    jthread thread,
1129    jint depth,
1130    jint slot,
1131    jlong* value_ptr);
1132
1133  /*   24 : Get Local Variable - Float */
1134  jvmtiError (JNICALL *GetLocalFloat) (jvmtiEnv* env,
1135    jthread thread,
1136    jint depth,
1137    jint slot,
1138    jfloat* value_ptr);
1139
1140  /*   25 : Get Local Variable - Double */
1141  jvmtiError (JNICALL *GetLocalDouble) (jvmtiEnv* env,
1142    jthread thread,
1143    jint depth,
1144    jint slot,
1145    jdouble* value_ptr);
1146
1147  /*   26 : Set Local Variable - Object */
1148  jvmtiError (JNICALL *SetLocalObject) (jvmtiEnv* env,
1149    jthread thread,
1150    jint depth,
1151    jint slot,
1152    jobject value);
1153
1154  /*   27 : Set Local Variable - Int */
1155  jvmtiError (JNICALL *SetLocalInt) (jvmtiEnv* env,
1156    jthread thread,
1157    jint depth,
1158    jint slot,
1159    jint value);
1160
1161  /*   28 : Set Local Variable - Long */
1162  jvmtiError (JNICALL *SetLocalLong) (jvmtiEnv* env,
1163    jthread thread,
1164    jint depth,
1165    jint slot,
1166    jlong value);
1167
1168  /*   29 : Set Local Variable - Float */
1169  jvmtiError (JNICALL *SetLocalFloat) (jvmtiEnv* env,
1170    jthread thread,
1171    jint depth,
1172    jint slot,
1173    jfloat value);
1174
1175  /*   30 : Set Local Variable - Double */
1176  jvmtiError (JNICALL *SetLocalDouble) (jvmtiEnv* env,
1177    jthread thread,
1178    jint depth,
1179    jint slot,
1180    jdouble value);
1181
1182  /*   31 : Create Raw Monitor */
1183  jvmtiError (JNICALL *CreateRawMonitor) (jvmtiEnv* env,
1184    const char* name,
1185    jrawMonitorID* monitor_ptr);
1186
1187  /*   32 : Destroy Raw Monitor */
1188  jvmtiError (JNICALL *DestroyRawMonitor) (jvmtiEnv* env,
1189    jrawMonitorID monitor);
1190
1191  /*   33 : Raw Monitor Enter */
1192  jvmtiError (JNICALL *RawMonitorEnter) (jvmtiEnv* env,
1193    jrawMonitorID monitor);
1194
1195  /*   34 : Raw Monitor Exit */
1196  jvmtiError (JNICALL *RawMonitorExit) (jvmtiEnv* env,
1197    jrawMonitorID monitor);
1198
1199  /*   35 : Raw Monitor Wait */
1200  jvmtiError (JNICALL *RawMonitorWait) (jvmtiEnv* env,
1201    jrawMonitorID monitor,
1202    jlong millis);
1203
1204  /*   36 : Raw Monitor Notify */
1205  jvmtiError (JNICALL *RawMonitorNotify) (jvmtiEnv* env,
1206    jrawMonitorID monitor);
1207
1208  /*   37 : Raw Monitor Notify All */
1209  jvmtiError (JNICALL *RawMonitorNotifyAll) (jvmtiEnv* env,
1210    jrawMonitorID monitor);
1211
1212  /*   38 : Set Breakpoint */
1213  jvmtiError (JNICALL *SetBreakpoint) (jvmtiEnv* env,
1214    jmethodID method,
1215    jlocation location);
1216
1217  /*   39 : Clear Breakpoint */
1218  jvmtiError (JNICALL *ClearBreakpoint) (jvmtiEnv* env,
1219    jmethodID method,
1220    jlocation location);
1221
1222  /*   40 : Get Named Module */
1223  jvmtiError (JNICALL *GetNamedModule) (jvmtiEnv* env,
1224    jobject class_loader,
1225    const char* package_name,
1226    jobject* module_ptr);
1227
1228  /*   41 : Set Field Access Watch */
1229  jvmtiError (JNICALL *SetFieldAccessWatch) (jvmtiEnv* env,
1230    jclass klass,
1231    jfieldID field);
1232
1233  /*   42 : Clear Field Access Watch */
1234  jvmtiError (JNICALL *ClearFieldAccessWatch) (jvmtiEnv* env,
1235    jclass klass,
1236    jfieldID field);
1237
1238  /*   43 : Set Field Modification Watch */
1239  jvmtiError (JNICALL *SetFieldModificationWatch) (jvmtiEnv* env,
1240    jclass klass,
1241    jfieldID field);
1242
1243  /*   44 : Clear Field Modification Watch */
1244  jvmtiError (JNICALL *ClearFieldModificationWatch) (jvmtiEnv* env,
1245    jclass klass,
1246    jfieldID field);
1247
1248  /*   45 : Is Modifiable Class */
1249  jvmtiError (JNICALL *IsModifiableClass) (jvmtiEnv* env,
1250    jclass klass,
1251    jboolean* is_modifiable_class_ptr);
1252
1253  /*   46 : Allocate */
1254  jvmtiError (JNICALL *Allocate) (jvmtiEnv* env,
1255    jlong size,
1256    unsigned char** mem_ptr);
1257
1258  /*   47 : Deallocate */
1259  jvmtiError (JNICALL *Deallocate) (jvmtiEnv* env,
1260    unsigned char* mem);
1261
1262  /*   48 : Get Class Signature */
1263  jvmtiError (JNICALL *GetClassSignature) (jvmtiEnv* env,
1264    jclass klass,
1265    char** signature_ptr,
1266    char** generic_ptr);
1267
1268  /*   49 : Get Class Status */
1269  jvmtiError (JNICALL *GetClassStatus) (jvmtiEnv* env,
1270    jclass klass,
1271    jint* status_ptr);
1272
1273  /*   50 : Get Source File Name */
1274  jvmtiError (JNICALL *GetSourceFileName) (jvmtiEnv* env,
1275    jclass klass,
1276    char** source_name_ptr);
1277
1278  /*   51 : Get Class Modifiers */
1279  jvmtiError (JNICALL *GetClassModifiers) (jvmtiEnv* env,
1280    jclass klass,
1281    jint* modifiers_ptr);
1282
1283  /*   52 : Get Class Methods */
1284  jvmtiError (JNICALL *GetClassMethods) (jvmtiEnv* env,
1285    jclass klass,
1286    jint* method_count_ptr,
1287    jmethodID** methods_ptr);
1288
1289  /*   53 : Get Class Fields */
1290  jvmtiError (JNICALL *GetClassFields) (jvmtiEnv* env,
1291    jclass klass,
1292    jint* field_count_ptr,
1293    jfieldID** fields_ptr);
1294
1295  /*   54 : Get Implemented Interfaces */
1296  jvmtiError (JNICALL *GetImplementedInterfaces) (jvmtiEnv* env,
1297    jclass klass,
1298    jint* interface_count_ptr,
1299    jclass** interfaces_ptr);
1300
1301  /*   55 : Is Interface */
1302  jvmtiError (JNICALL *IsInterface) (jvmtiEnv* env,
1303    jclass klass,
1304    jboolean* is_interface_ptr);
1305
1306  /*   56 : Is Array Class */
1307  jvmtiError (JNICALL *IsArrayClass) (jvmtiEnv* env,
1308    jclass klass,
1309    jboolean* is_array_class_ptr);
1310
1311  /*   57 : Get Class Loader */
1312  jvmtiError (JNICALL *GetClassLoader) (jvmtiEnv* env,
1313    jclass klass,
1314    jobject* classloader_ptr);
1315
1316  /*   58 : Get Object Hash Code */
1317  jvmtiError (JNICALL *GetObjectHashCode) (jvmtiEnv* env,
1318    jobject object,
1319    jint* hash_code_ptr);
1320
1321  /*   59 : Get Object Monitor Usage */
1322  jvmtiError (JNICALL *GetObjectMonitorUsage) (jvmtiEnv* env,
1323    jobject object,
1324    jvmtiMonitorUsage* info_ptr);
1325
1326  /*   60 : Get Field Name (and Signature) */
1327  jvmtiError (JNICALL *GetFieldName) (jvmtiEnv* env,
1328    jclass klass,
1329    jfieldID field,
1330    char** name_ptr,
1331    char** signature_ptr,
1332    char** generic_ptr);
1333
1334  /*   61 : Get Field Declaring Class */
1335  jvmtiError (JNICALL *GetFieldDeclaringClass) (jvmtiEnv* env,
1336    jclass klass,
1337    jfieldID field,
1338    jclass* declaring_class_ptr);
1339
1340  /*   62 : Get Field Modifiers */
1341  jvmtiError (JNICALL *GetFieldModifiers) (jvmtiEnv* env,
1342    jclass klass,
1343    jfieldID field,
1344    jint* modifiers_ptr);
1345
1346  /*   63 : Is Field Synthetic */
1347  jvmtiError (JNICALL *IsFieldSynthetic) (jvmtiEnv* env,
1348    jclass klass,
1349    jfieldID field,
1350    jboolean* is_synthetic_ptr);
1351
1352  /*   64 : Get Method Name (and Signature) */
1353  jvmtiError (JNICALL *GetMethodName) (jvmtiEnv* env,
1354    jmethodID method,
1355    char** name_ptr,
1356    char** signature_ptr,
1357    char** generic_ptr);
1358
1359  /*   65 : Get Method Declaring Class */
1360  jvmtiError (JNICALL *GetMethodDeclaringClass) (jvmtiEnv* env,
1361    jmethodID method,
1362    jclass* declaring_class_ptr);
1363
1364  /*   66 : Get Method Modifiers */
1365  jvmtiError (JNICALL *GetMethodModifiers) (jvmtiEnv* env,
1366    jmethodID method,
1367    jint* modifiers_ptr);
1368
1369  /*   67 :  RESERVED */
1370  void *reserved67;
1371
1372  /*   68 : Get Max Locals */
1373  jvmtiError (JNICALL *GetMaxLocals) (jvmtiEnv* env,
1374    jmethodID method,
1375    jint* max_ptr);
1376
1377  /*   69 : Get Arguments Size */
1378  jvmtiError (JNICALL *GetArgumentsSize) (jvmtiEnv* env,
1379    jmethodID method,
1380    jint* size_ptr);
1381
1382  /*   70 : Get Line Number Table */
1383  jvmtiError (JNICALL *GetLineNumberTable) (jvmtiEnv* env,
1384    jmethodID method,
1385    jint* entry_count_ptr,
1386    jvmtiLineNumberEntry** table_ptr);
1387
1388  /*   71 : Get Method Location */
1389  jvmtiError (JNICALL *GetMethodLocation) (jvmtiEnv* env,
1390    jmethodID method,
1391    jlocation* start_location_ptr,
1392    jlocation* end_location_ptr);
1393
1394  /*   72 : Get Local Variable Table */
1395  jvmtiError (JNICALL *GetLocalVariableTable) (jvmtiEnv* env,
1396    jmethodID method,
1397    jint* entry_count_ptr,
1398    jvmtiLocalVariableEntry** table_ptr);
1399
1400  /*   73 : Set Native Method Prefix */
1401  jvmtiError (JNICALL *SetNativeMethodPrefix) (jvmtiEnv* env,
1402    const char* prefix);
1403
1404  /*   74 : Set Native Method Prefixes */
1405  jvmtiError (JNICALL *SetNativeMethodPrefixes) (jvmtiEnv* env,
1406    jint prefix_count,
1407    char** prefixes);
1408
1409  /*   75 : Get Bytecodes */
1410  jvmtiError (JNICALL *GetBytecodes) (jvmtiEnv* env,
1411    jmethodID method,
1412    jint* bytecode_count_ptr,
1413    unsigned char** bytecodes_ptr);
1414
1415  /*   76 : Is Method Native */
1416  jvmtiError (JNICALL *IsMethodNative) (jvmtiEnv* env,
1417    jmethodID method,
1418    jboolean* is_native_ptr);
1419
1420  /*   77 : Is Method Synthetic */
1421  jvmtiError (JNICALL *IsMethodSynthetic) (jvmtiEnv* env,
1422    jmethodID method,
1423    jboolean* is_synthetic_ptr);
1424
1425  /*   78 : Get Loaded Classes */
1426  jvmtiError (JNICALL *GetLoadedClasses) (jvmtiEnv* env,
1427    jint* class_count_ptr,
1428    jclass** classes_ptr);
1429
1430  /*   79 : Get Classloader Classes */
1431  jvmtiError (JNICALL *GetClassLoaderClasses) (jvmtiEnv* env,
1432    jobject initiating_loader,
1433    jint* class_count_ptr,
1434    jclass** classes_ptr);
1435
1436  /*   80 : Pop Frame */
1437  jvmtiError (JNICALL *PopFrame) (jvmtiEnv* env,
1438    jthread thread);
1439
1440  /*   81 : Force Early Return - Object */
1441  jvmtiError (JNICALL *ForceEarlyReturnObject) (jvmtiEnv* env,
1442    jthread thread,
1443    jobject value);
1444
1445  /*   82 : Force Early Return - Int */
1446  jvmtiError (JNICALL *ForceEarlyReturnInt) (jvmtiEnv* env,
1447    jthread thread,
1448    jint value);
1449
1450  /*   83 : Force Early Return - Long */
1451  jvmtiError (JNICALL *ForceEarlyReturnLong) (jvmtiEnv* env,
1452    jthread thread,
1453    jlong value);
1454
1455  /*   84 : Force Early Return - Float */
1456  jvmtiError (JNICALL *ForceEarlyReturnFloat) (jvmtiEnv* env,
1457    jthread thread,
1458    jfloat value);
1459
1460  /*   85 : Force Early Return - Double */
1461  jvmtiError (JNICALL *ForceEarlyReturnDouble) (jvmtiEnv* env,
1462    jthread thread,
1463    jdouble value);
1464
1465  /*   86 : Force Early Return - Void */
1466  jvmtiError (JNICALL *ForceEarlyReturnVoid) (jvmtiEnv* env,
1467    jthread thread);
1468
1469  /*   87 : Redefine Classes */
1470  jvmtiError (JNICALL *RedefineClasses) (jvmtiEnv* env,
1471    jint class_count,
1472    const jvmtiClassDefinition* class_definitions);
1473
1474  /*   88 : Get Version Number */
1475  jvmtiError (JNICALL *GetVersionNumber) (jvmtiEnv* env,
1476    jint* version_ptr);
1477
1478  /*   89 : Get Capabilities */
1479  jvmtiError (JNICALL *GetCapabilities) (jvmtiEnv* env,
1480    jvmtiCapabilities* capabilities_ptr);
1481
1482  /*   90 : Get Source Debug Extension */
1483  jvmtiError (JNICALL *GetSourceDebugExtension) (jvmtiEnv* env,
1484    jclass klass,
1485    char** source_debug_extension_ptr);
1486
1487  /*   91 : Is Method Obsolete */
1488  jvmtiError (JNICALL *IsMethodObsolete) (jvmtiEnv* env,
1489    jmethodID method,
1490    jboolean* is_obsolete_ptr);
1491
1492  /*   92 : Suspend Thread List */
1493  jvmtiError (JNICALL *SuspendThreadList) (jvmtiEnv* env,
1494    jint request_count,
1495    const jthread* request_list,
1496    jvmtiError* results);
1497
1498  /*   93 : Resume Thread List */
1499  jvmtiError (JNICALL *ResumeThreadList) (jvmtiEnv* env,
1500    jint request_count,
1501    const jthread* request_list,
1502    jvmtiError* results);
1503
1504  /*   94 : Add Module Reads */
1505  jvmtiError (JNICALL *AddModuleReads) (jvmtiEnv* env,
1506    jobject module,
1507    jobject to_module);
1508
1509  /*   95 : Add Module Exports */
1510  jvmtiError (JNICALL *AddModuleExports) (jvmtiEnv* env,
1511    jobject module,
1512    const char* pkg_name,
1513    jobject to_module);
1514
1515  /*   96 : Add Module Opens */
1516  jvmtiError (JNICALL *AddModuleOpens) (jvmtiEnv* env,
1517    jobject module,
1518    const char* pkg_name,
1519    jobject to_module);
1520
1521  /*   97 : Add Module Uses */
1522  jvmtiError (JNICALL *AddModuleUses) (jvmtiEnv* env,
1523    jobject module,
1524    jclass service);
1525
1526  /*   98 : Add Module Provides */
1527  jvmtiError (JNICALL *AddModuleProvides) (jvmtiEnv* env,
1528    jobject module,
1529    jclass service,
1530    jclass impl_class);
1531
1532  /*   99 : Is Modifiable Module */
1533  jvmtiError (JNICALL *IsModifiableModule) (jvmtiEnv* env,
1534    jobject module,
1535    jboolean* is_modifiable_module_ptr);
1536
1537  /*   100 : Get All Stack Traces */
1538  jvmtiError (JNICALL *GetAllStackTraces) (jvmtiEnv* env,
1539    jint max_frame_count,
1540    jvmtiStackInfo** stack_info_ptr,
1541    jint* thread_count_ptr);
1542
1543  /*   101 : Get Thread List Stack Traces */
1544  jvmtiError (JNICALL *GetThreadListStackTraces) (jvmtiEnv* env,
1545    jint thread_count,
1546    const jthread* thread_list,
1547    jint max_frame_count,
1548    jvmtiStackInfo** stack_info_ptr);
1549
1550  /*   102 : Get Thread Local Storage */
1551  jvmtiError (JNICALL *GetThreadLocalStorage) (jvmtiEnv* env,
1552    jthread thread,
1553    void** data_ptr);
1554
1555  /*   103 : Set Thread Local Storage */
1556  jvmtiError (JNICALL *SetThreadLocalStorage) (jvmtiEnv* env,
1557    jthread thread,
1558    const void* data);
1559
1560  /*   104 : Get Stack Trace */
1561  jvmtiError (JNICALL *GetStackTrace) (jvmtiEnv* env,
1562    jthread thread,
1563    jint start_depth,
1564    jint max_frame_count,
1565    jvmtiFrameInfo* frame_buffer,
1566    jint* count_ptr);
1567
1568  /*   105 :  RESERVED */
1569  void *reserved105;
1570
1571  /*   106 : Get Tag */
1572  jvmtiError (JNICALL *GetTag) (jvmtiEnv* env,
1573    jobject object,
1574    jlong* tag_ptr);
1575
1576  /*   107 : Set Tag */
1577  jvmtiError (JNICALL *SetTag) (jvmtiEnv* env,
1578    jobject object,
1579    jlong tag);
1580
1581  /*   108 : Force Garbage Collection */
1582  jvmtiError (JNICALL *ForceGarbageCollection) (jvmtiEnv* env);
1583
1584  /*   109 : Iterate Over Objects Reachable From Object */
1585  jvmtiError (JNICALL *IterateOverObjectsReachableFromObject) (jvmtiEnv* env,
1586    jobject object,
1587    jvmtiObjectReferenceCallback object_reference_callback,
1588    const void* user_data);
1589
1590  /*   110 : Iterate Over Reachable Objects */
1591  jvmtiError (JNICALL *IterateOverReachableObjects) (jvmtiEnv* env,
1592    jvmtiHeapRootCallback heap_root_callback,
1593    jvmtiStackReferenceCallback stack_ref_callback,
1594    jvmtiObjectReferenceCallback object_ref_callback,
1595    const void* user_data);
1596
1597  /*   111 : Iterate Over Heap */
1598  jvmtiError (JNICALL *IterateOverHeap) (jvmtiEnv* env,
1599    jvmtiHeapObjectFilter object_filter,
1600    jvmtiHeapObjectCallback heap_object_callback,
1601    const void* user_data);
1602
1603  /*   112 : Iterate Over Instances Of Class */
1604  jvmtiError (JNICALL *IterateOverInstancesOfClass) (jvmtiEnv* env,
1605    jclass klass,
1606    jvmtiHeapObjectFilter object_filter,
1607    jvmtiHeapObjectCallback heap_object_callback,
1608    const void* user_data);
1609
1610  /*   113 :  RESERVED */
1611  void *reserved113;
1612
1613  /*   114 : Get Objects With Tags */
1614  jvmtiError (JNICALL *GetObjectsWithTags) (jvmtiEnv* env,
1615    jint tag_count,
1616    const jlong* tags,
1617    jint* count_ptr,
1618    jobject** object_result_ptr,
1619    jlong** tag_result_ptr);
1620
1621  /*   115 : Follow References */
1622  jvmtiError (JNICALL *FollowReferences) (jvmtiEnv* env,
1623    jint heap_filter,
1624    jclass klass,
1625    jobject initial_object,
1626    const jvmtiHeapCallbacks* callbacks,
1627    const void* user_data);
1628
1629  /*   116 : Iterate Through Heap */
1630  jvmtiError (JNICALL *IterateThroughHeap) (jvmtiEnv* env,
1631    jint heap_filter,
1632    jclass klass,
1633    const jvmtiHeapCallbacks* callbacks,
1634    const void* user_data);
1635
1636  /*   117 :  RESERVED */
1637  void *reserved117;
1638
1639  /*   118 :  RESERVED */
1640  void *reserved118;
1641
1642  /*   119 :  RESERVED */
1643  void *reserved119;
1644
1645  /*   120 : Set JNI Function Table */
1646  jvmtiError (JNICALL *SetJNIFunctionTable) (jvmtiEnv* env,
1647    const jniNativeInterface* function_table);
1648
1649  /*   121 : Get JNI Function Table */
1650  jvmtiError (JNICALL *GetJNIFunctionTable) (jvmtiEnv* env,
1651    jniNativeInterface** function_table);
1652
1653  /*   122 : Set Event Callbacks */
1654  jvmtiError (JNICALL *SetEventCallbacks) (jvmtiEnv* env,
1655    const jvmtiEventCallbacks* callbacks,
1656    jint size_of_callbacks);
1657
1658  /*   123 : Generate Events */
1659  jvmtiError (JNICALL *GenerateEvents) (jvmtiEnv* env,
1660    jvmtiEvent event_type);
1661
1662  /*   124 : Get Extension Functions */
1663  jvmtiError (JNICALL *GetExtensionFunctions) (jvmtiEnv* env,
1664    jint* extension_count_ptr,
1665    jvmtiExtensionFunctionInfo** extensions);
1666
1667  /*   125 : Get Extension Events */
1668  jvmtiError (JNICALL *GetExtensionEvents) (jvmtiEnv* env,
1669    jint* extension_count_ptr,
1670    jvmtiExtensionEventInfo** extensions);
1671
1672  /*   126 : Set Extension Event Callback */
1673  jvmtiError (JNICALL *SetExtensionEventCallback) (jvmtiEnv* env,
1674    jint extension_event_index,
1675    jvmtiExtensionEvent callback);
1676
1677  /*   127 : Dispose Environment */
1678  jvmtiError (JNICALL *DisposeEnvironment) (jvmtiEnv* env);
1679
1680  /*   128 : Get Error Name */
1681  jvmtiError (JNICALL *GetErrorName) (jvmtiEnv* env,
1682    jvmtiError error,
1683    char** name_ptr);
1684
1685  /*   129 : Get JLocation Format */
1686  jvmtiError (JNICALL *GetJLocationFormat) (jvmtiEnv* env,
1687    jvmtiJlocationFormat* format_ptr);
1688
1689  /*   130 : Get System Properties */
1690  jvmtiError (JNICALL *GetSystemProperties) (jvmtiEnv* env,
1691    jint* count_ptr,
1692    char*** property_ptr);
1693
1694  /*   131 : Get System Property */
1695  jvmtiError (JNICALL *GetSystemProperty) (jvmtiEnv* env,
1696    const char* property,
1697    char** value_ptr);
1698
1699  /*   132 : Set System Property */
1700  jvmtiError (JNICALL *SetSystemProperty) (jvmtiEnv* env,
1701    const char* property,
1702    const char* value_ptr);
1703
1704  /*   133 : Get Phase */
1705  jvmtiError (JNICALL *GetPhase) (jvmtiEnv* env,
1706    jvmtiPhase* phase_ptr);
1707
1708  /*   134 : Get Current Thread CPU Timer Information */
1709  jvmtiError (JNICALL *GetCurrentThreadCpuTimerInfo) (jvmtiEnv* env,
1710    jvmtiTimerInfo* info_ptr);
1711
1712  /*   135 : Get Current Thread CPU Time */
1713  jvmtiError (JNICALL *GetCurrentThreadCpuTime) (jvmtiEnv* env,
1714    jlong* nanos_ptr);
1715
1716  /*   136 : Get Thread CPU Timer Information */
1717  jvmtiError (JNICALL *GetThreadCpuTimerInfo) (jvmtiEnv* env,
1718    jvmtiTimerInfo* info_ptr);
1719
1720  /*   137 : Get Thread CPU Time */
1721  jvmtiError (JNICALL *GetThreadCpuTime) (jvmtiEnv* env,
1722    jthread thread,
1723    jlong* nanos_ptr);
1724
1725  /*   138 : Get Timer Information */
1726  jvmtiError (JNICALL *GetTimerInfo) (jvmtiEnv* env,
1727    jvmtiTimerInfo* info_ptr);
1728
1729  /*   139 : Get Time */
1730  jvmtiError (JNICALL *GetTime) (jvmtiEnv* env,
1731    jlong* nanos_ptr);
1732
1733  /*   140 : Get Potential Capabilities */
1734  jvmtiError (JNICALL *GetPotentialCapabilities) (jvmtiEnv* env,
1735    jvmtiCapabilities* capabilities_ptr);
1736
1737  /*   141 :  RESERVED */
1738  void *reserved141;
1739
1740  /*   142 : Add Capabilities */
1741  jvmtiError (JNICALL *AddCapabilities) (jvmtiEnv* env,
1742    const jvmtiCapabilities* capabilities_ptr);
1743
1744  /*   143 : Relinquish Capabilities */
1745  jvmtiError (JNICALL *RelinquishCapabilities) (jvmtiEnv* env,
1746    const jvmtiCapabilities* capabilities_ptr);
1747
1748  /*   144 : Get Available Processors */
1749  jvmtiError (JNICALL *GetAvailableProcessors) (jvmtiEnv* env,
1750    jint* processor_count_ptr);
1751
1752  /*   145 : Get Class Version Numbers */
1753  jvmtiError (JNICALL *GetClassVersionNumbers) (jvmtiEnv* env,
1754    jclass klass,
1755    jint* minor_version_ptr,
1756    jint* major_version_ptr);
1757
1758  /*   146 : Get Constant Pool */
1759  jvmtiError (JNICALL *GetConstantPool) (jvmtiEnv* env,
1760    jclass klass,
1761    jint* constant_pool_count_ptr,
1762    jint* constant_pool_byte_count_ptr,
1763    unsigned char** constant_pool_bytes_ptr);
1764
1765  /*   147 : Get Environment Local Storage */
1766  jvmtiError (JNICALL *GetEnvironmentLocalStorage) (jvmtiEnv* env,
1767    void** data_ptr);
1768
1769  /*   148 : Set Environment Local Storage */
1770  jvmtiError (JNICALL *SetEnvironmentLocalStorage) (jvmtiEnv* env,
1771    const void* data);
1772
1773  /*   149 : Add To Bootstrap Class Loader Search */
1774  jvmtiError (JNICALL *AddToBootstrapClassLoaderSearch) (jvmtiEnv* env,
1775    const char* segment);
1776
1777  /*   150 : Set Verbose Flag */
1778  jvmtiError (JNICALL *SetVerboseFlag) (jvmtiEnv* env,
1779    jvmtiVerboseFlag flag,
1780    jboolean value);
1781
1782  /*   151 : Add To System Class Loader Search */
1783  jvmtiError (JNICALL *AddToSystemClassLoaderSearch) (jvmtiEnv* env,
1784    const char* segment);
1785
1786  /*   152 : Retransform Classes */
1787  jvmtiError (JNICALL *RetransformClasses) (jvmtiEnv* env,
1788    jint class_count,
1789    const jclass* classes);
1790
1791  /*   153 : Get Owned Monitor Stack Depth Info */
1792  jvmtiError (JNICALL *GetOwnedMonitorStackDepthInfo) (jvmtiEnv* env,
1793    jthread thread,
1794    jint* monitor_info_count_ptr,
1795    jvmtiMonitorStackDepthInfo** monitor_info_ptr);
1796
1797  /*   154 : Get Object Size */
1798  jvmtiError (JNICALL *GetObjectSize) (jvmtiEnv* env,
1799    jobject object,
1800    jlong* size_ptr);
1801
1802  /*   155 : Get Local Instance */
1803  jvmtiError (JNICALL *GetLocalInstance) (jvmtiEnv* env,
1804    jthread thread,
1805    jint depth,
1806    jobject* value_ptr);
1807
1808} jvmtiInterface_1;
1809
1810struct _jvmtiEnv {
1811    const struct jvmtiInterface_1_ *functions;
1812#ifdef __cplusplus
1813
1814
1815  jvmtiError Allocate(jlong size,
1816            unsigned char** mem_ptr) {
1817    return functions->Allocate(this, size, mem_ptr);
1818  }
1819
1820  jvmtiError Deallocate(unsigned char* mem) {
1821    return functions->Deallocate(this, mem);
1822  }
1823
1824  jvmtiError GetThreadState(jthread thread,
1825            jint* thread_state_ptr) {
1826    return functions->GetThreadState(this, thread, thread_state_ptr);
1827  }
1828
1829  jvmtiError GetCurrentThread(jthread* thread_ptr) {
1830    return functions->GetCurrentThread(this, thread_ptr);
1831  }
1832
1833  jvmtiError GetAllThreads(jint* threads_count_ptr,
1834            jthread** threads_ptr) {
1835    return functions->GetAllThreads(this, threads_count_ptr, threads_ptr);
1836  }
1837
1838  jvmtiError SuspendThread(jthread thread) {
1839    return functions->SuspendThread(this, thread);
1840  }
1841
1842  jvmtiError SuspendThreadList(jint request_count,
1843            const jthread* request_list,
1844            jvmtiError* results) {
1845    return functions->SuspendThreadList(this, request_count, request_list, results);
1846  }
1847
1848  jvmtiError ResumeThread(jthread thread) {
1849    return functions->ResumeThread(this, thread);
1850  }
1851
1852  jvmtiError ResumeThreadList(jint request_count,
1853            const jthread* request_list,
1854            jvmtiError* results) {
1855    return functions->ResumeThreadList(this, request_count, request_list, results);
1856  }
1857
1858  jvmtiError StopThread(jthread thread,
1859            jobject exception) {
1860    return functions->StopThread(this, thread, exception);
1861  }
1862
1863  jvmtiError InterruptThread(jthread thread) {
1864    return functions->InterruptThread(this, thread);
1865  }
1866
1867  jvmtiError GetThreadInfo(jthread thread,
1868            jvmtiThreadInfo* info_ptr) {
1869    return functions->GetThreadInfo(this, thread, info_ptr);
1870  }
1871
1872  jvmtiError GetOwnedMonitorInfo(jthread thread,
1873            jint* owned_monitor_count_ptr,
1874            jobject** owned_monitors_ptr) {
1875    return functions->GetOwnedMonitorInfo(this, thread, owned_monitor_count_ptr, owned_monitors_ptr);
1876  }
1877
1878  jvmtiError GetOwnedMonitorStackDepthInfo(jthread thread,
1879            jint* monitor_info_count_ptr,
1880            jvmtiMonitorStackDepthInfo** monitor_info_ptr) {
1881    return functions->GetOwnedMonitorStackDepthInfo(this, thread, monitor_info_count_ptr, monitor_info_ptr);
1882  }
1883
1884  jvmtiError GetCurrentContendedMonitor(jthread thread,
1885            jobject* monitor_ptr) {
1886    return functions->GetCurrentContendedMonitor(this, thread, monitor_ptr);
1887  }
1888
1889  jvmtiError RunAgentThread(jthread thread,
1890            jvmtiStartFunction proc,
1891            const void* arg,
1892            jint priority) {
1893    return functions->RunAgentThread(this, thread, proc, arg, priority);
1894  }
1895
1896  jvmtiError SetThreadLocalStorage(jthread thread,
1897            const void* data) {
1898    return functions->SetThreadLocalStorage(this, thread, data);
1899  }
1900
1901  jvmtiError GetThreadLocalStorage(jthread thread,
1902            void** data_ptr) {
1903    return functions->GetThreadLocalStorage(this, thread, data_ptr);
1904  }
1905
1906  jvmtiError GetTopThreadGroups(jint* group_count_ptr,
1907            jthreadGroup** groups_ptr) {
1908    return functions->GetTopThreadGroups(this, group_count_ptr, groups_ptr);
1909  }
1910
1911  jvmtiError GetThreadGroupInfo(jthreadGroup group,
1912            jvmtiThreadGroupInfo* info_ptr) {
1913    return functions->GetThreadGroupInfo(this, group, info_ptr);
1914  }
1915
1916  jvmtiError GetThreadGroupChildren(jthreadGroup group,
1917            jint* thread_count_ptr,
1918            jthread** threads_ptr,
1919            jint* group_count_ptr,
1920            jthreadGroup** groups_ptr) {
1921    return functions->GetThreadGroupChildren(this, group, thread_count_ptr, threads_ptr, group_count_ptr, groups_ptr);
1922  }
1923
1924  jvmtiError GetStackTrace(jthread thread,
1925            jint start_depth,
1926            jint max_frame_count,
1927            jvmtiFrameInfo* frame_buffer,
1928            jint* count_ptr) {
1929    return functions->GetStackTrace(this, thread, start_depth, max_frame_count, frame_buffer, count_ptr);
1930  }
1931
1932  jvmtiError GetAllStackTraces(jint max_frame_count,
1933            jvmtiStackInfo** stack_info_ptr,
1934            jint* thread_count_ptr) {
1935    return functions->GetAllStackTraces(this, max_frame_count, stack_info_ptr, thread_count_ptr);
1936  }
1937
1938  jvmtiError GetThreadListStackTraces(jint thread_count,
1939            const jthread* thread_list,
1940            jint max_frame_count,
1941            jvmtiStackInfo** stack_info_ptr) {
1942    return functions->GetThreadListStackTraces(this, thread_count, thread_list, max_frame_count, stack_info_ptr);
1943  }
1944
1945  jvmtiError GetFrameCount(jthread thread,
1946            jint* count_ptr) {
1947    return functions->GetFrameCount(this, thread, count_ptr);
1948  }
1949
1950  jvmtiError PopFrame(jthread thread) {
1951    return functions->PopFrame(this, thread);
1952  }
1953
1954  jvmtiError GetFrameLocation(jthread thread,
1955            jint depth,
1956            jmethodID* method_ptr,
1957            jlocation* location_ptr) {
1958    return functions->GetFrameLocation(this, thread, depth, method_ptr, location_ptr);
1959  }
1960
1961  jvmtiError NotifyFramePop(jthread thread,
1962            jint depth) {
1963    return functions->NotifyFramePop(this, thread, depth);
1964  }
1965
1966  jvmtiError ForceEarlyReturnObject(jthread thread,
1967            jobject value) {
1968    return functions->ForceEarlyReturnObject(this, thread, value);
1969  }
1970
1971  jvmtiError ForceEarlyReturnInt(jthread thread,
1972            jint value) {
1973    return functions->ForceEarlyReturnInt(this, thread, value);
1974  }
1975
1976  jvmtiError ForceEarlyReturnLong(jthread thread,
1977            jlong value) {
1978    return functions->ForceEarlyReturnLong(this, thread, value);
1979  }
1980
1981  jvmtiError ForceEarlyReturnFloat(jthread thread,
1982            jfloat value) {
1983    return functions->ForceEarlyReturnFloat(this, thread, value);
1984  }
1985
1986  jvmtiError ForceEarlyReturnDouble(jthread thread,
1987            jdouble value) {
1988    return functions->ForceEarlyReturnDouble(this, thread, value);
1989  }
1990
1991  jvmtiError ForceEarlyReturnVoid(jthread thread) {
1992    return functions->ForceEarlyReturnVoid(this, thread);
1993  }
1994
1995  jvmtiError FollowReferences(jint heap_filter,
1996            jclass klass,
1997            jobject initial_object,
1998            const jvmtiHeapCallbacks* callbacks,
1999            const void* user_data) {
2000    return functions->FollowReferences(this, heap_filter, klass, initial_object, callbacks, user_data);
2001  }
2002
2003  jvmtiError IterateThroughHeap(jint heap_filter,
2004            jclass klass,
2005            const jvmtiHeapCallbacks* callbacks,
2006            const void* user_data) {
2007    return functions->IterateThroughHeap(this, heap_filter, klass, callbacks, user_data);
2008  }
2009
2010  jvmtiError GetTag(jobject object,
2011            jlong* tag_ptr) {
2012    return functions->GetTag(this, object, tag_ptr);
2013  }
2014
2015  jvmtiError SetTag(jobject object,
2016            jlong tag) {
2017    return functions->SetTag(this, object, tag);
2018  }
2019
2020  jvmtiError GetObjectsWithTags(jint tag_count,
2021            const jlong* tags,
2022            jint* count_ptr,
2023            jobject** object_result_ptr,
2024            jlong** tag_result_ptr) {
2025    return functions->GetObjectsWithTags(this, tag_count, tags, count_ptr, object_result_ptr, tag_result_ptr);
2026  }
2027
2028  jvmtiError ForceGarbageCollection() {
2029    return functions->ForceGarbageCollection(this);
2030  }
2031
2032  jvmtiError IterateOverObjectsReachableFromObject(jobject object,
2033            jvmtiObjectReferenceCallback object_reference_callback,
2034            const void* user_data) {
2035    return functions->IterateOverObjectsReachableFromObject(this, object, object_reference_callback, user_data);
2036  }
2037
2038  jvmtiError IterateOverReachableObjects(jvmtiHeapRootCallback heap_root_callback,
2039            jvmtiStackReferenceCallback stack_ref_callback,
2040            jvmtiObjectReferenceCallback object_ref_callback,
2041            const void* user_data) {
2042    return functions->IterateOverReachableObjects(this, heap_root_callback, stack_ref_callback, object_ref_callback, user_data);
2043  }
2044
2045  jvmtiError IterateOverHeap(jvmtiHeapObjectFilter object_filter,
2046            jvmtiHeapObjectCallback heap_object_callback,
2047            const void* user_data) {
2048    return functions->IterateOverHeap(this, object_filter, heap_object_callback, user_data);
2049  }
2050
2051  jvmtiError IterateOverInstancesOfClass(jclass klass,
2052            jvmtiHeapObjectFilter object_filter,
2053            jvmtiHeapObjectCallback heap_object_callback,
2054            const void* user_data) {
2055    return functions->IterateOverInstancesOfClass(this, klass, object_filter, heap_object_callback, user_data);
2056  }
2057
2058  jvmtiError GetLocalObject(jthread thread,
2059            jint depth,
2060            jint slot,
2061            jobject* value_ptr) {
2062    return functions->GetLocalObject(this, thread, depth, slot, value_ptr);
2063  }
2064
2065  jvmtiError GetLocalInstance(jthread thread,
2066            jint depth,
2067            jobject* value_ptr) {
2068    return functions->GetLocalInstance(this, thread, depth, value_ptr);
2069  }
2070
2071  jvmtiError GetLocalInt(jthread thread,
2072            jint depth,
2073            jint slot,
2074            jint* value_ptr) {
2075    return functions->GetLocalInt(this, thread, depth, slot, value_ptr);
2076  }
2077
2078  jvmtiError GetLocalLong(jthread thread,
2079            jint depth,
2080            jint slot,
2081            jlong* value_ptr) {
2082    return functions->GetLocalLong(this, thread, depth, slot, value_ptr);
2083  }
2084
2085  jvmtiError GetLocalFloat(jthread thread,
2086            jint depth,
2087            jint slot,
2088            jfloat* value_ptr) {
2089    return functions->GetLocalFloat(this, thread, depth, slot, value_ptr);
2090  }
2091
2092  jvmtiError GetLocalDouble(jthread thread,
2093            jint depth,
2094            jint slot,
2095            jdouble* value_ptr) {
2096    return functions->GetLocalDouble(this, thread, depth, slot, value_ptr);
2097  }
2098
2099  jvmtiError SetLocalObject(jthread thread,
2100            jint depth,
2101            jint slot,
2102            jobject value) {
2103    return functions->SetLocalObject(this, thread, depth, slot, value);
2104  }
2105
2106  jvmtiError SetLocalInt(jthread thread,
2107            jint depth,
2108            jint slot,
2109            jint value) {
2110    return functions->SetLocalInt(this, thread, depth, slot, value);
2111  }
2112
2113  jvmtiError SetLocalLong(jthread thread,
2114            jint depth,
2115            jint slot,
2116            jlong value) {
2117    return functions->SetLocalLong(this, thread, depth, slot, value);
2118  }
2119
2120  jvmtiError SetLocalFloat(jthread thread,
2121            jint depth,
2122            jint slot,
2123            jfloat value) {
2124    return functions->SetLocalFloat(this, thread, depth, slot, value);
2125  }
2126
2127  jvmtiError SetLocalDouble(jthread thread,
2128            jint depth,
2129            jint slot,
2130            jdouble value) {
2131    return functions->SetLocalDouble(this, thread, depth, slot, value);
2132  }
2133
2134  jvmtiError SetBreakpoint(jmethodID method,
2135            jlocation location) {
2136    return functions->SetBreakpoint(this, method, location);
2137  }
2138
2139  jvmtiError ClearBreakpoint(jmethodID method,
2140            jlocation location) {
2141    return functions->ClearBreakpoint(this, method, location);
2142  }
2143
2144  jvmtiError SetFieldAccessWatch(jclass klass,
2145            jfieldID field) {
2146    return functions->SetFieldAccessWatch(this, klass, field);
2147  }
2148
2149  jvmtiError ClearFieldAccessWatch(jclass klass,
2150            jfieldID field) {
2151    return functions->ClearFieldAccessWatch(this, klass, field);
2152  }
2153
2154  jvmtiError SetFieldModificationWatch(jclass klass,
2155            jfieldID field) {
2156    return functions->SetFieldModificationWatch(this, klass, field);
2157  }
2158
2159  jvmtiError ClearFieldModificationWatch(jclass klass,
2160            jfieldID field) {
2161    return functions->ClearFieldModificationWatch(this, klass, field);
2162  }
2163
2164  jvmtiError GetAllModules(jint* module_count_ptr,
2165            jobject** modules_ptr) {
2166    return functions->GetAllModules(this, module_count_ptr, modules_ptr);
2167  }
2168
2169  jvmtiError GetNamedModule(jobject class_loader,
2170            const char* package_name,
2171            jobject* module_ptr) {
2172    return functions->GetNamedModule(this, class_loader, package_name, module_ptr);
2173  }
2174
2175  jvmtiError AddModuleReads(jobject module,
2176            jobject to_module) {
2177    return functions->AddModuleReads(this, module, to_module);
2178  }
2179
2180  jvmtiError AddModuleExports(jobject module,
2181            const char* pkg_name,
2182            jobject to_module) {
2183    return functions->AddModuleExports(this, module, pkg_name, to_module);
2184  }
2185
2186  jvmtiError AddModuleOpens(jobject module,
2187            const char* pkg_name,
2188            jobject to_module) {
2189    return functions->AddModuleOpens(this, module, pkg_name, to_module);
2190  }
2191
2192  jvmtiError AddModuleUses(jobject module,
2193            jclass service) {
2194    return functions->AddModuleUses(this, module, service);
2195  }
2196
2197  jvmtiError AddModuleProvides(jobject module,
2198            jclass service,
2199            jclass impl_class) {
2200    return functions->AddModuleProvides(this, module, service, impl_class);
2201  }
2202
2203  jvmtiError IsModifiableModule(jobject module,
2204            jboolean* is_modifiable_module_ptr) {
2205    return functions->IsModifiableModule(this, module, is_modifiable_module_ptr);
2206  }
2207
2208  jvmtiError GetLoadedClasses(jint* class_count_ptr,
2209            jclass** classes_ptr) {
2210    return functions->GetLoadedClasses(this, class_count_ptr, classes_ptr);
2211  }
2212
2213  jvmtiError GetClassLoaderClasses(jobject initiating_loader,
2214            jint* class_count_ptr,
2215            jclass** classes_ptr) {
2216    return functions->GetClassLoaderClasses(this, initiating_loader, class_count_ptr, classes_ptr);
2217  }
2218
2219  jvmtiError GetClassSignature(jclass klass,
2220            char** signature_ptr,
2221            char** generic_ptr) {
2222    return functions->GetClassSignature(this, klass, signature_ptr, generic_ptr);
2223  }
2224
2225  jvmtiError GetClassStatus(jclass klass,
2226            jint* status_ptr) {
2227    return functions->GetClassStatus(this, klass, status_ptr);
2228  }
2229
2230  jvmtiError GetSourceFileName(jclass klass,
2231            char** source_name_ptr) {
2232    return functions->GetSourceFileName(this, klass, source_name_ptr);
2233  }
2234
2235  jvmtiError GetClassModifiers(jclass klass,
2236            jint* modifiers_ptr) {
2237    return functions->GetClassModifiers(this, klass, modifiers_ptr);
2238  }
2239
2240  jvmtiError GetClassMethods(jclass klass,
2241            jint* method_count_ptr,
2242            jmethodID** methods_ptr) {
2243    return functions->GetClassMethods(this, klass, method_count_ptr, methods_ptr);
2244  }
2245
2246  jvmtiError GetClassFields(jclass klass,
2247            jint* field_count_ptr,
2248            jfieldID** fields_ptr) {
2249    return functions->GetClassFields(this, klass, field_count_ptr, fields_ptr);
2250  }
2251
2252  jvmtiError GetImplementedInterfaces(jclass klass,
2253            jint* interface_count_ptr,
2254            jclass** interfaces_ptr) {
2255    return functions->GetImplementedInterfaces(this, klass, interface_count_ptr, interfaces_ptr);
2256  }
2257
2258  jvmtiError GetClassVersionNumbers(jclass klass,
2259            jint* minor_version_ptr,
2260            jint* major_version_ptr) {
2261    return functions->GetClassVersionNumbers(this, klass, minor_version_ptr, major_version_ptr);
2262  }
2263
2264  jvmtiError GetConstantPool(jclass klass,
2265            jint* constant_pool_count_ptr,
2266            jint* constant_pool_byte_count_ptr,
2267            unsigned char** constant_pool_bytes_ptr) {
2268    return functions->GetConstantPool(this, klass, constant_pool_count_ptr, constant_pool_byte_count_ptr, constant_pool_bytes_ptr);
2269  }
2270
2271  jvmtiError IsInterface(jclass klass,
2272            jboolean* is_interface_ptr) {
2273    return functions->IsInterface(this, klass, is_interface_ptr);
2274  }
2275
2276  jvmtiError IsArrayClass(jclass klass,
2277            jboolean* is_array_class_ptr) {
2278    return functions->IsArrayClass(this, klass, is_array_class_ptr);
2279  }
2280
2281  jvmtiError IsModifiableClass(jclass klass,
2282            jboolean* is_modifiable_class_ptr) {
2283    return functions->IsModifiableClass(this, klass, is_modifiable_class_ptr);
2284  }
2285
2286  jvmtiError GetClassLoader(jclass klass,
2287            jobject* classloader_ptr) {
2288    return functions->GetClassLoader(this, klass, classloader_ptr);
2289  }
2290
2291  jvmtiError GetSourceDebugExtension(jclass klass,
2292            char** source_debug_extension_ptr) {
2293    return functions->GetSourceDebugExtension(this, klass, source_debug_extension_ptr);
2294  }
2295
2296  jvmtiError RetransformClasses(jint class_count,
2297            const jclass* classes) {
2298    return functions->RetransformClasses(this, class_count, classes);
2299  }
2300
2301  jvmtiError RedefineClasses(jint class_count,
2302            const jvmtiClassDefinition* class_definitions) {
2303    return functions->RedefineClasses(this, class_count, class_definitions);
2304  }
2305
2306  jvmtiError GetObjectSize(jobject object,
2307            jlong* size_ptr) {
2308    return functions->GetObjectSize(this, object, size_ptr);
2309  }
2310
2311  jvmtiError GetObjectHashCode(jobject object,
2312            jint* hash_code_ptr) {
2313    return functions->GetObjectHashCode(this, object, hash_code_ptr);
2314  }
2315
2316  jvmtiError GetObjectMonitorUsage(jobject object,
2317            jvmtiMonitorUsage* info_ptr) {
2318    return functions->GetObjectMonitorUsage(this, object, info_ptr);
2319  }
2320
2321  jvmtiError GetFieldName(jclass klass,
2322            jfieldID field,
2323            char** name_ptr,
2324            char** signature_ptr,
2325            char** generic_ptr) {
2326    return functions->GetFieldName(this, klass, field, name_ptr, signature_ptr, generic_ptr);
2327  }
2328
2329  jvmtiError GetFieldDeclaringClass(jclass klass,
2330            jfieldID field,
2331            jclass* declaring_class_ptr) {
2332    return functions->GetFieldDeclaringClass(this, klass, field, declaring_class_ptr);
2333  }
2334
2335  jvmtiError GetFieldModifiers(jclass klass,
2336            jfieldID field,
2337            jint* modifiers_ptr) {
2338    return functions->GetFieldModifiers(this, klass, field, modifiers_ptr);
2339  }
2340
2341  jvmtiError IsFieldSynthetic(jclass klass,
2342            jfieldID field,
2343            jboolean* is_synthetic_ptr) {
2344    return functions->IsFieldSynthetic(this, klass, field, is_synthetic_ptr);
2345  }
2346
2347  jvmtiError GetMethodName(jmethodID method,
2348            char** name_ptr,
2349            char** signature_ptr,
2350            char** generic_ptr) {
2351    return functions->GetMethodName(this, method, name_ptr, signature_ptr, generic_ptr);
2352  }
2353
2354  jvmtiError GetMethodDeclaringClass(jmethodID method,
2355            jclass* declaring_class_ptr) {
2356    return functions->GetMethodDeclaringClass(this, method, declaring_class_ptr);
2357  }
2358
2359  jvmtiError GetMethodModifiers(jmethodID method,
2360            jint* modifiers_ptr) {
2361    return functions->GetMethodModifiers(this, method, modifiers_ptr);
2362  }
2363
2364  jvmtiError GetMaxLocals(jmethodID method,
2365            jint* max_ptr) {
2366    return functions->GetMaxLocals(this, method, max_ptr);
2367  }
2368
2369  jvmtiError GetArgumentsSize(jmethodID method,
2370            jint* size_ptr) {
2371    return functions->GetArgumentsSize(this, method, size_ptr);
2372  }
2373
2374  jvmtiError GetLineNumberTable(jmethodID method,
2375            jint* entry_count_ptr,
2376            jvmtiLineNumberEntry** table_ptr) {
2377    return functions->GetLineNumberTable(this, method, entry_count_ptr, table_ptr);
2378  }
2379
2380  jvmtiError GetMethodLocation(jmethodID method,
2381            jlocation* start_location_ptr,
2382            jlocation* end_location_ptr) {
2383    return functions->GetMethodLocation(this, method, start_location_ptr, end_location_ptr);
2384  }
2385
2386  jvmtiError GetLocalVariableTable(jmethodID method,
2387            jint* entry_count_ptr,
2388            jvmtiLocalVariableEntry** table_ptr) {
2389    return functions->GetLocalVariableTable(this, method, entry_count_ptr, table_ptr);
2390  }
2391
2392  jvmtiError GetBytecodes(jmethodID method,
2393            jint* bytecode_count_ptr,
2394            unsigned char** bytecodes_ptr) {
2395    return functions->GetBytecodes(this, method, bytecode_count_ptr, bytecodes_ptr);
2396  }
2397
2398  jvmtiError IsMethodNative(jmethodID method,
2399            jboolean* is_native_ptr) {
2400    return functions->IsMethodNative(this, method, is_native_ptr);
2401  }
2402
2403  jvmtiError IsMethodSynthetic(jmethodID method,
2404            jboolean* is_synthetic_ptr) {
2405    return functions->IsMethodSynthetic(this, method, is_synthetic_ptr);
2406  }
2407
2408  jvmtiError IsMethodObsolete(jmethodID method,
2409            jboolean* is_obsolete_ptr) {
2410    return functions->IsMethodObsolete(this, method, is_obsolete_ptr);
2411  }
2412
2413  jvmtiError SetNativeMethodPrefix(const char* prefix) {
2414    return functions->SetNativeMethodPrefix(this, prefix);
2415  }
2416
2417  jvmtiError SetNativeMethodPrefixes(jint prefix_count,
2418            char** prefixes) {
2419    return functions->SetNativeMethodPrefixes(this, prefix_count, prefixes);
2420  }
2421
2422  jvmtiError CreateRawMonitor(const char* name,
2423            jrawMonitorID* monitor_ptr) {
2424    return functions->CreateRawMonitor(this, name, monitor_ptr);
2425  }
2426
2427  jvmtiError DestroyRawMonitor(jrawMonitorID monitor) {
2428    return functions->DestroyRawMonitor(this, monitor);
2429  }
2430
2431  jvmtiError RawMonitorEnter(jrawMonitorID monitor) {
2432    return functions->RawMonitorEnter(this, monitor);
2433  }
2434
2435  jvmtiError RawMonitorExit(jrawMonitorID monitor) {
2436    return functions->RawMonitorExit(this, monitor);
2437  }
2438
2439  jvmtiError RawMonitorWait(jrawMonitorID monitor,
2440            jlong millis) {
2441    return functions->RawMonitorWait(this, monitor, millis);
2442  }
2443
2444  jvmtiError RawMonitorNotify(jrawMonitorID monitor) {
2445    return functions->RawMonitorNotify(this, monitor);
2446  }
2447
2448  jvmtiError RawMonitorNotifyAll(jrawMonitorID monitor) {
2449    return functions->RawMonitorNotifyAll(this, monitor);
2450  }
2451
2452  jvmtiError SetJNIFunctionTable(const jniNativeInterface* function_table) {
2453    return functions->SetJNIFunctionTable(this, function_table);
2454  }
2455
2456  jvmtiError GetJNIFunctionTable(jniNativeInterface** function_table) {
2457    return functions->GetJNIFunctionTable(this, function_table);
2458  }
2459
2460  jvmtiError SetEventCallbacks(const jvmtiEventCallbacks* callbacks,
2461            jint size_of_callbacks) {
2462    return functions->SetEventCallbacks(this, callbacks, size_of_callbacks);
2463  }
2464
2465  jvmtiError SetEventNotificationMode(jvmtiEventMode mode,
2466            jvmtiEvent event_type,
2467            jthread event_thread,
2468             ...) {
2469    return functions->SetEventNotificationMode(this, mode, event_type, event_thread);
2470  }
2471
2472  jvmtiError GenerateEvents(jvmtiEvent event_type) {
2473    return functions->GenerateEvents(this, event_type);
2474  }
2475
2476  jvmtiError GetExtensionFunctions(jint* extension_count_ptr,
2477            jvmtiExtensionFunctionInfo** extensions) {
2478    return functions->GetExtensionFunctions(this, extension_count_ptr, extensions);
2479  }
2480
2481  jvmtiError GetExtensionEvents(jint* extension_count_ptr,
2482            jvmtiExtensionEventInfo** extensions) {
2483    return functions->GetExtensionEvents(this, extension_count_ptr, extensions);
2484  }
2485
2486  jvmtiError SetExtensionEventCallback(jint extension_event_index,
2487            jvmtiExtensionEvent callback) {
2488    return functions->SetExtensionEventCallback(this, extension_event_index, callback);
2489  }
2490
2491  jvmtiError GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) {
2492    return functions->GetPotentialCapabilities(this, capabilities_ptr);
2493  }
2494
2495  jvmtiError AddCapabilities(const jvmtiCapabilities* capabilities_ptr) {
2496    return functions->AddCapabilities(this, capabilities_ptr);
2497  }
2498
2499  jvmtiError RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) {
2500    return functions->RelinquishCapabilities(this, capabilities_ptr);
2501  }
2502
2503  jvmtiError GetCapabilities(jvmtiCapabilities* capabilities_ptr) {
2504    return functions->GetCapabilities(this, capabilities_ptr);
2505  }
2506
2507  jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) {
2508    return functions->GetCurrentThreadCpuTimerInfo(this, info_ptr);
2509  }
2510
2511  jvmtiError GetCurrentThreadCpuTime(jlong* nanos_ptr) {
2512    return functions->GetCurrentThreadCpuTime(this, nanos_ptr);
2513  }
2514
2515  jvmtiError GetThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) {
2516    return functions->GetThreadCpuTimerInfo(this, info_ptr);
2517  }
2518
2519  jvmtiError GetThreadCpuTime(jthread thread,
2520            jlong* nanos_ptr) {
2521    return functions->GetThreadCpuTime(this, thread, nanos_ptr);
2522  }
2523
2524  jvmtiError GetTimerInfo(jvmtiTimerInfo* info_ptr) {
2525    return functions->GetTimerInfo(this, info_ptr);
2526  }
2527
2528  jvmtiError GetTime(jlong* nanos_ptr) {
2529    return functions->GetTime(this, nanos_ptr);
2530  }
2531
2532  jvmtiError GetAvailableProcessors(jint* processor_count_ptr) {
2533    return functions->GetAvailableProcessors(this, processor_count_ptr);
2534  }
2535
2536  jvmtiError AddToBootstrapClassLoaderSearch(const char* segment) {
2537    return functions->AddToBootstrapClassLoaderSearch(this, segment);
2538  }
2539
2540  jvmtiError AddToSystemClassLoaderSearch(const char* segment) {
2541    return functions->AddToSystemClassLoaderSearch(this, segment);
2542  }
2543
2544  jvmtiError GetSystemProperties(jint* count_ptr,
2545            char*** property_ptr) {
2546    return functions->GetSystemProperties(this, count_ptr, property_ptr);
2547  }
2548
2549  jvmtiError GetSystemProperty(const char* property,
2550            char** value_ptr) {
2551    return functions->GetSystemProperty(this, property, value_ptr);
2552  }
2553
2554  jvmtiError SetSystemProperty(const char* property,
2555            const char* value_ptr) {
2556    return functions->SetSystemProperty(this, property, value_ptr);
2557  }
2558
2559  jvmtiError GetPhase(jvmtiPhase* phase_ptr) {
2560    return functions->GetPhase(this, phase_ptr);
2561  }
2562
2563  jvmtiError DisposeEnvironment() {
2564    return functions->DisposeEnvironment(this);
2565  }
2566
2567  jvmtiError SetEnvironmentLocalStorage(const void* data) {
2568    return functions->SetEnvironmentLocalStorage(this, data);
2569  }
2570
2571  jvmtiError GetEnvironmentLocalStorage(void** data_ptr) {
2572    return functions->GetEnvironmentLocalStorage(this, data_ptr);
2573  }
2574
2575  jvmtiError GetVersionNumber(jint* version_ptr) {
2576    return functions->GetVersionNumber(this, version_ptr);
2577  }
2578
2579  jvmtiError GetErrorName(jvmtiError error,
2580            char** name_ptr) {
2581    return functions->GetErrorName(this, error, name_ptr);
2582  }
2583
2584  jvmtiError SetVerboseFlag(jvmtiVerboseFlag flag,
2585            jboolean value) {
2586    return functions->SetVerboseFlag(this, flag, value);
2587  }
2588
2589  jvmtiError GetJLocationFormat(jvmtiJlocationFormat* format_ptr) {
2590    return functions->GetJLocationFormat(this, format_ptr);
2591  }
2592
2593#endif /* __cplusplus */
2594};
2595
2596
2597#ifdef __cplusplus
2598} /* extern "C" */
2599#endif /* __cplusplus */
2600
2601#endif /* !_JAVA_JVMTI_H_ */
2602