CoCalc -- jvmti.h

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/jdk/src/share/javavm/export/jvmti.h
³⁸⁸¹³ views
1
/*
2
 * Copyright (c) 2003, 2011, 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

29
    /* Include file for the Java(tm) Virtual Machine Tool Interface */
30

31
#ifndef _JAVA_JVMTI_H_
32
#define _JAVA_JVMTI_H_
33

34
#include "jni.h"
35

36
#ifdef __cplusplus
37
extern "C" {
38
#endif
39

40
enum {
41
    JVMTI_VERSION_1   = 0x30010000,
42
    JVMTI_VERSION_1_0 = 0x30010000,
43
    JVMTI_VERSION_1_1 = 0x30010100,
44
    JVMTI_VERSION_1_2 = 0x30010200,
45

46
    JVMTI_VERSION = 0x30000000 + (1 * 0x10000) + (2 * 0x100) + 1  /* version: 1.2.1 */
47
};
48

49
JNIEXPORT jint JNICALL
50
Agent_OnLoad(JavaVM *vm, char *options, void *reserved);
51

52
JNIEXPORT jint JNICALL
53
Agent_OnAttach(JavaVM* vm, char* options, void* reserved);
54

55
JNIEXPORT void JNICALL
56
Agent_OnUnload(JavaVM *vm);
57

58
    /* Forward declaration of the environment */
59

60
struct _jvmtiEnv;
61

62
struct jvmtiInterface_1_;
63

64
#ifdef __cplusplus
65
typedef _jvmtiEnv jvmtiEnv;
66
#else
67
typedef const struct jvmtiInterface_1_ *jvmtiEnv;
68
#endif /* __cplusplus */
69

70
/* Derived Base Types */
71

72
typedef jobject jthread;
73
typedef jobject jthreadGroup;
74
typedef jlong jlocation;
75
struct _jrawMonitorID;
76
typedef struct _jrawMonitorID *jrawMonitorID;
77
typedef struct JNINativeInterface_ jniNativeInterface;
78

79
    /* Constants */
80

81

82
    /* Thread State Flags */
83

84
enum {
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

105
enum {
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

117
enum {
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

125
enum {
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

134
enum {
135
    JVMTI_VISIT_OBJECTS = 0x100,
136
    JVMTI_VISIT_ABORT = 0x8000
137
};
138

139
    /* Heap Reference Enumeration */
140

141
typedef 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

163
typedef 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

176
typedef 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

184
typedef 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

196
typedef 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

210
typedef enum {
211
    JVMTI_ITERATION_CONTINUE = 1,
212
    JVMTI_ITERATION_IGNORE = 2,
213
    JVMTI_ITERATION_ABORT = 0
214
} jvmtiIterationControl;
215

216
    /* Class Status Flags */
217

218
enum {
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

229
typedef enum {
230
    JVMTI_ENABLE = 1,
231
    JVMTI_DISABLE = 0
232
} jvmtiEventMode;
233

234
    /* Extension Function/Event Parameter Types */
235

236
typedef 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

258
typedef 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

270
typedef 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

278
typedef 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

288
enum {
289
    JVMTI_VERSION_INTERFACE_JNI = 0x00000000,
290
    JVMTI_VERSION_INTERFACE_JVMTI = 0x30000000
291
};
292

293
    /* Version Masks */
294

295
enum {
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

304
enum {
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

312
typedef 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

321
typedef enum {
322
    JVMTI_JLOCATION_JVMBCI = 1,
323
    JVMTI_JLOCATION_MACHINEPC = 2,
324
    JVMTI_JLOCATION_OTHER = 0
325
} jvmtiJlocationFormat;
326

327
    /* Resource Exhaustion Flags */
328

329
enum {
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

337
typedef 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_NO_MORE_FRAMES = 31,
352
    JVMTI_ERROR_OPAQUE_FRAME = 32,
353
    JVMTI_ERROR_TYPE_MISMATCH = 34,
354
    JVMTI_ERROR_INVALID_SLOT = 35,
355
    JVMTI_ERROR_DUPLICATE = 40,
356
    JVMTI_ERROR_NOT_FOUND = 41,
357
    JVMTI_ERROR_INVALID_MONITOR = 50,
358
    JVMTI_ERROR_NOT_MONITOR_OWNER = 51,
359
    JVMTI_ERROR_INTERRUPT = 52,
360
    JVMTI_ERROR_INVALID_CLASS_FORMAT = 60,
361
    JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61,
362
    JVMTI_ERROR_FAILS_VERIFICATION = 62,
363
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63,
364
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64,
365
    JVMTI_ERROR_INVALID_TYPESTATE = 65,
366
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66,
367
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67,
368
    JVMTI_ERROR_UNSUPPORTED_VERSION = 68,
369
    JVMTI_ERROR_NAMES_DONT_MATCH = 69,
370
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70,
371
    JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71,
372
    JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
373
    JVMTI_ERROR_NOT_AVAILABLE = 98,
374
    JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99,
375
    JVMTI_ERROR_NULL_POINTER = 100,
376
    JVMTI_ERROR_ABSENT_INFORMATION = 101,
377
    JVMTI_ERROR_INVALID_EVENT_TYPE = 102,
378
    JVMTI_ERROR_ILLEGAL_ARGUMENT = 103,
379
    JVMTI_ERROR_NATIVE_METHOD = 104,
380
    JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED = 106,
381
    JVMTI_ERROR_OUT_OF_MEMORY = 110,
382
    JVMTI_ERROR_ACCESS_DENIED = 111,
383
    JVMTI_ERROR_WRONG_PHASE = 112,
384
    JVMTI_ERROR_INTERNAL = 113,
385
    JVMTI_ERROR_UNATTACHED_THREAD = 115,
386
    JVMTI_ERROR_INVALID_ENVIRONMENT = 116,
387
    JVMTI_ERROR_MAX = 116
388
} jvmtiError;
389

390
    /* Event IDs */
391

392
typedef enum {
393
    JVMTI_MIN_EVENT_TYPE_VAL = 50,
394
    JVMTI_EVENT_VM_INIT = 50,
395
    JVMTI_EVENT_VM_DEATH = 51,
396
    JVMTI_EVENT_THREAD_START = 52,
397
    JVMTI_EVENT_THREAD_END = 53,
398
    JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54,
399
    JVMTI_EVENT_CLASS_LOAD = 55,
400
    JVMTI_EVENT_CLASS_PREPARE = 56,
401
    JVMTI_EVENT_VM_START = 57,
402
    JVMTI_EVENT_EXCEPTION = 58,
403
    JVMTI_EVENT_EXCEPTION_CATCH = 59,
404
    JVMTI_EVENT_SINGLE_STEP = 60,
405
    JVMTI_EVENT_FRAME_POP = 61,
406
    JVMTI_EVENT_BREAKPOINT = 62,
407
    JVMTI_EVENT_FIELD_ACCESS = 63,
408
    JVMTI_EVENT_FIELD_MODIFICATION = 64,
409
    JVMTI_EVENT_METHOD_ENTRY = 65,
410
    JVMTI_EVENT_METHOD_EXIT = 66,
411
    JVMTI_EVENT_NATIVE_METHOD_BIND = 67,
412
    JVMTI_EVENT_COMPILED_METHOD_LOAD = 68,
413
    JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69,
414
    JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70,
415
    JVMTI_EVENT_DATA_DUMP_REQUEST = 71,
416
    JVMTI_EVENT_MONITOR_WAIT = 73,
417
    JVMTI_EVENT_MONITOR_WAITED = 74,
418
    JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75,
419
    JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76,
420
    JVMTI_EVENT_RESOURCE_EXHAUSTED = 80,
421
    JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
422
    JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
423
    JVMTI_EVENT_OBJECT_FREE = 83,
424
    JVMTI_EVENT_VM_OBJECT_ALLOC = 84,
425
    JVMTI_MAX_EVENT_TYPE_VAL = 84
426
} jvmtiEvent;
427

428

429
    /* Pre-Declarations */
430
struct _jvmtiThreadInfo;
431
typedef struct _jvmtiThreadInfo jvmtiThreadInfo;
432
struct _jvmtiMonitorStackDepthInfo;
433
typedef struct _jvmtiMonitorStackDepthInfo jvmtiMonitorStackDepthInfo;
434
struct _jvmtiThreadGroupInfo;
435
typedef struct _jvmtiThreadGroupInfo jvmtiThreadGroupInfo;
436
struct _jvmtiFrameInfo;
437
typedef struct _jvmtiFrameInfo jvmtiFrameInfo;
438
struct _jvmtiStackInfo;
439
typedef struct _jvmtiStackInfo jvmtiStackInfo;
440
struct _jvmtiHeapReferenceInfoField;
441
typedef struct _jvmtiHeapReferenceInfoField jvmtiHeapReferenceInfoField;
442
struct _jvmtiHeapReferenceInfoArray;
443
typedef struct _jvmtiHeapReferenceInfoArray jvmtiHeapReferenceInfoArray;
444
struct _jvmtiHeapReferenceInfoConstantPool;
445
typedef struct _jvmtiHeapReferenceInfoConstantPool jvmtiHeapReferenceInfoConstantPool;
446
struct _jvmtiHeapReferenceInfoStackLocal;
447
typedef struct _jvmtiHeapReferenceInfoStackLocal jvmtiHeapReferenceInfoStackLocal;
448
struct _jvmtiHeapReferenceInfoJniLocal;
449
typedef struct _jvmtiHeapReferenceInfoJniLocal jvmtiHeapReferenceInfoJniLocal;
450
struct _jvmtiHeapReferenceInfoReserved;
451
typedef struct _jvmtiHeapReferenceInfoReserved jvmtiHeapReferenceInfoReserved;
452
union _jvmtiHeapReferenceInfo;
453
typedef union _jvmtiHeapReferenceInfo jvmtiHeapReferenceInfo;
454
struct _jvmtiHeapCallbacks;
455
typedef struct _jvmtiHeapCallbacks jvmtiHeapCallbacks;
456
struct _jvmtiClassDefinition;
457
typedef struct _jvmtiClassDefinition jvmtiClassDefinition;
458
struct _jvmtiMonitorUsage;
459
typedef struct _jvmtiMonitorUsage jvmtiMonitorUsage;
460
struct _jvmtiLineNumberEntry;
461
typedef struct _jvmtiLineNumberEntry jvmtiLineNumberEntry;
462
struct _jvmtiLocalVariableEntry;
463
typedef struct _jvmtiLocalVariableEntry jvmtiLocalVariableEntry;
464
struct _jvmtiParamInfo;
465
typedef struct _jvmtiParamInfo jvmtiParamInfo;
466
struct _jvmtiExtensionFunctionInfo;
467
typedef struct _jvmtiExtensionFunctionInfo jvmtiExtensionFunctionInfo;
468
struct _jvmtiExtensionEventInfo;
469
typedef struct _jvmtiExtensionEventInfo jvmtiExtensionEventInfo;
470
struct _jvmtiTimerInfo;
471
typedef struct _jvmtiTimerInfo jvmtiTimerInfo;
472
struct _jvmtiAddrLocationMap;
473
typedef struct _jvmtiAddrLocationMap jvmtiAddrLocationMap;
474

475
    /* Function Types */
476

477
typedef void (JNICALL *jvmtiStartFunction)
478
    (jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg);
479

480
typedef jint (JNICALL *jvmtiHeapIterationCallback)
481
    (jlong class_tag, jlong size, jlong* tag_ptr, jint length, void* user_data);
482

483
typedef jint (JNICALL *jvmtiHeapReferenceCallback)
484
    (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);
485

486
typedef jint (JNICALL *jvmtiPrimitiveFieldCallback)
487
    (jvmtiHeapReferenceKind kind, const jvmtiHeapReferenceInfo* info, jlong object_class_tag, jlong* object_tag_ptr, jvalue value, jvmtiPrimitiveType value_type, void* user_data);
488

489
typedef jint (JNICALL *jvmtiArrayPrimitiveValueCallback)
490
    (jlong class_tag, jlong size, jlong* tag_ptr, jint element_count, jvmtiPrimitiveType element_type, const void* elements, void* user_data);
491

492
typedef jint (JNICALL *jvmtiStringPrimitiveValueCallback)
493
    (jlong class_tag, jlong size, jlong* tag_ptr, const jchar* value, jint value_length, void* user_data);
494

495
typedef jint (JNICALL *jvmtiReservedCallback)
496
    ();
497

498
typedef jvmtiIterationControl (JNICALL *jvmtiHeapObjectCallback)
499
    (jlong class_tag, jlong size, jlong* tag_ptr, void* user_data);
500

501
typedef jvmtiIterationControl (JNICALL *jvmtiHeapRootCallback)
502
    (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, void* user_data);
503

504
typedef jvmtiIterationControl (JNICALL *jvmtiStackReferenceCallback)
505
    (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong thread_tag, jint depth, jmethodID method, jint slot, void* user_data);
506

507
typedef jvmtiIterationControl (JNICALL *jvmtiObjectReferenceCallback)
508
    (jvmtiObjectReferenceKind reference_kind, jlong class_tag, jlong size, jlong* tag_ptr, jlong referrer_tag, jint referrer_index, void* user_data);
509

510
typedef jvmtiError (JNICALL *jvmtiExtensionFunction)
511
    (jvmtiEnv* jvmti_env,  ...);
512

513
typedef void (JNICALL *jvmtiExtensionEvent)
514
    (jvmtiEnv* jvmti_env,  ...);
515

516

517
    /* Structure Types */
518
struct _jvmtiThreadInfo {
519
    char* name;
520
    jint priority;
521
    jboolean is_daemon;
522
    jthreadGroup thread_group;
523
    jobject context_class_loader;
524
};
525
struct _jvmtiMonitorStackDepthInfo {
526
    jobject monitor;
527
    jint stack_depth;
528
};
529
struct _jvmtiThreadGroupInfo {
530
    jthreadGroup parent;
531
    char* name;
532
    jint max_priority;
533
    jboolean is_daemon;
534
};
535
struct _jvmtiFrameInfo {
536
    jmethodID method;
537
    jlocation location;
538
};
539
struct _jvmtiStackInfo {
540
    jthread thread;
541
    jint state;
542
    jvmtiFrameInfo* frame_buffer;
543
    jint frame_count;
544
};
545
struct _jvmtiHeapReferenceInfoField {
546
    jint index;
547
};
548
struct _jvmtiHeapReferenceInfoArray {
549
    jint index;
550
};
551
struct _jvmtiHeapReferenceInfoConstantPool {
552
    jint index;
553
};
554
struct _jvmtiHeapReferenceInfoStackLocal {
555
    jlong thread_tag;
556
    jlong thread_id;
557
    jint depth;
558
    jmethodID method;
559
    jlocation location;
560
    jint slot;
561
};
562
struct _jvmtiHeapReferenceInfoJniLocal {
563
    jlong thread_tag;
564
    jlong thread_id;
565
    jint depth;
566
    jmethodID method;
567
};
568
struct _jvmtiHeapReferenceInfoReserved {
569
    jlong reserved1;
570
    jlong reserved2;
571
    jlong reserved3;
572
    jlong reserved4;
573
    jlong reserved5;
574
    jlong reserved6;
575
    jlong reserved7;
576
    jlong reserved8;
577
};
578
union _jvmtiHeapReferenceInfo {
579
    jvmtiHeapReferenceInfoField field;
580
    jvmtiHeapReferenceInfoArray array;
581
    jvmtiHeapReferenceInfoConstantPool constant_pool;
582
    jvmtiHeapReferenceInfoStackLocal stack_local;
583
    jvmtiHeapReferenceInfoJniLocal jni_local;
584
    jvmtiHeapReferenceInfoReserved other;
585
};
586
struct _jvmtiHeapCallbacks {
587
    jvmtiHeapIterationCallback heap_iteration_callback;
588
    jvmtiHeapReferenceCallback heap_reference_callback;
589
    jvmtiPrimitiveFieldCallback primitive_field_callback;
590
    jvmtiArrayPrimitiveValueCallback array_primitive_value_callback;
591
    jvmtiStringPrimitiveValueCallback string_primitive_value_callback;
592
    jvmtiReservedCallback reserved5;
593
    jvmtiReservedCallback reserved6;
594
    jvmtiReservedCallback reserved7;
595
    jvmtiReservedCallback reserved8;
596
    jvmtiReservedCallback reserved9;
597
    jvmtiReservedCallback reserved10;
598
    jvmtiReservedCallback reserved11;
599
    jvmtiReservedCallback reserved12;
600
    jvmtiReservedCallback reserved13;
601
    jvmtiReservedCallback reserved14;
602
    jvmtiReservedCallback reserved15;
603
};
604
struct _jvmtiClassDefinition {
605
    jclass klass;
606
    jint class_byte_count;
607
    const unsigned char* class_bytes;
608
};
609
struct _jvmtiMonitorUsage {
610
    jthread owner;
611
    jint entry_count;
612
    jint waiter_count;
613
    jthread* waiters;
614
    jint notify_waiter_count;
615
    jthread* notify_waiters;
616
};
617
struct _jvmtiLineNumberEntry {
618
    jlocation start_location;
619
    jint line_number;
620
};
621
struct _jvmtiLocalVariableEntry {
622
    jlocation start_location;
623
    jint length;
624
    char* name;
625
    char* signature;
626
    char* generic_signature;
627
    jint slot;
628
};
629
struct _jvmtiParamInfo {
630
    char* name;
631
    jvmtiParamKind kind;
632
    jvmtiParamTypes base_type;
633
    jboolean null_ok;
634
};
635
struct _jvmtiExtensionFunctionInfo {
636
    jvmtiExtensionFunction func;
637
    char* id;
638
    char* short_description;
639
    jint param_count;
640
    jvmtiParamInfo* params;
641
    jint error_count;
642
    jvmtiError* errors;
643
};
644
struct _jvmtiExtensionEventInfo {
645
    jint extension_event_index;
646
    char* id;
647
    char* short_description;
648
    jint param_count;
649
    jvmtiParamInfo* params;
650
};
651
struct _jvmtiTimerInfo {
652
    jlong max_value;
653
    jboolean may_skip_forward;
654
    jboolean may_skip_backward;
655
    jvmtiTimerKind kind;
656
    jlong reserved1;
657
    jlong reserved2;
658
};
659
struct _jvmtiAddrLocationMap {
660
    const void* start_address;
661
    jlocation location;
662
};
663

664
typedef struct {
665
    unsigned int can_tag_objects : 1;
666
    unsigned int can_generate_field_modification_events : 1;
667
    unsigned int can_generate_field_access_events : 1;
668
    unsigned int can_get_bytecodes : 1;
669
    unsigned int can_get_synthetic_attribute : 1;
670
    unsigned int can_get_owned_monitor_info : 1;
671
    unsigned int can_get_current_contended_monitor : 1;
672
    unsigned int can_get_monitor_info : 1;
673
    unsigned int can_pop_frame : 1;
674
    unsigned int can_redefine_classes : 1;
675
    unsigned int can_signal_thread : 1;
676
    unsigned int can_get_source_file_name : 1;
677
    unsigned int can_get_line_numbers : 1;
678
    unsigned int can_get_source_debug_extension : 1;
679
    unsigned int can_access_local_variables : 1;
680
    unsigned int can_maintain_original_method_order : 1;
681
    unsigned int can_generate_single_step_events : 1;
682
    unsigned int can_generate_exception_events : 1;
683
    unsigned int can_generate_frame_pop_events : 1;
684
    unsigned int can_generate_breakpoint_events : 1;
685
    unsigned int can_suspend : 1;
686
    unsigned int can_redefine_any_class : 1;
687
    unsigned int can_get_current_thread_cpu_time : 1;
688
    unsigned int can_get_thread_cpu_time : 1;
689
    unsigned int can_generate_method_entry_events : 1;
690
    unsigned int can_generate_method_exit_events : 1;
691
    unsigned int can_generate_all_class_hook_events : 1;
692
    unsigned int can_generate_compiled_method_load_events : 1;
693
    unsigned int can_generate_monitor_events : 1;
694
    unsigned int can_generate_vm_object_alloc_events : 1;
695
    unsigned int can_generate_native_method_bind_events : 1;
696
    unsigned int can_generate_garbage_collection_events : 1;
697
    unsigned int can_generate_object_free_events : 1;
698
    unsigned int can_force_early_return : 1;
699
    unsigned int can_get_owned_monitor_stack_depth_info : 1;
700
    unsigned int can_get_constant_pool : 1;
701
    unsigned int can_set_native_method_prefix : 1;
702
    unsigned int can_retransform_classes : 1;
703
    unsigned int can_retransform_any_class : 1;
704
    unsigned int can_generate_resource_exhaustion_heap_events : 1;
705
    unsigned int can_generate_resource_exhaustion_threads_events : 1;
706
    unsigned int : 7;
707
    unsigned int : 16;
708
    unsigned int : 16;
709
    unsigned int : 16;
710
    unsigned int : 16;
711
    unsigned int : 16;
712
} jvmtiCapabilities;
713

714

715
    /* Event Definitions */
716

717
typedef void (JNICALL *jvmtiEventReserved)(void);
718

719

720
typedef void (JNICALL *jvmtiEventBreakpoint)
721
    (jvmtiEnv *jvmti_env,
722
     JNIEnv* jni_env,
723
     jthread thread,
724
     jmethodID method,
725
     jlocation location);
726

727
typedef void (JNICALL *jvmtiEventClassFileLoadHook)
728
    (jvmtiEnv *jvmti_env,
729
     JNIEnv* jni_env,
730
     jclass class_being_redefined,
731
     jobject loader,
732
     const char* name,
733
     jobject protection_domain,
734
     jint class_data_len,
735
     const unsigned char* class_data,
736
     jint* new_class_data_len,
737
     unsigned char** new_class_data);
738

739
typedef void (JNICALL *jvmtiEventClassLoad)
740
    (jvmtiEnv *jvmti_env,
741
     JNIEnv* jni_env,
742
     jthread thread,
743
     jclass klass);
744

745
typedef void (JNICALL *jvmtiEventClassPrepare)
746
    (jvmtiEnv *jvmti_env,
747
     JNIEnv* jni_env,
748
     jthread thread,
749
     jclass klass);
750

751
typedef void (JNICALL *jvmtiEventCompiledMethodLoad)
752
    (jvmtiEnv *jvmti_env,
753
     jmethodID method,
754
     jint code_size,
755
     const void* code_addr,
756
     jint map_length,
757
     const jvmtiAddrLocationMap* map,
758
     const void* compile_info);
759

760
typedef void (JNICALL *jvmtiEventCompiledMethodUnload)
761
    (jvmtiEnv *jvmti_env,
762
     jmethodID method,
763
     const void* code_addr);
764

765
typedef void (JNICALL *jvmtiEventDataDumpRequest)
766
    (jvmtiEnv *jvmti_env);
767

768
typedef void (JNICALL *jvmtiEventDynamicCodeGenerated)
769
    (jvmtiEnv *jvmti_env,
770
     const char* name,
771
     const void* address,
772
     jint length);
773

774
typedef void (JNICALL *jvmtiEventException)
775
    (jvmtiEnv *jvmti_env,
776
     JNIEnv* jni_env,
777
     jthread thread,
778
     jmethodID method,
779
     jlocation location,
780
     jobject exception,
781
     jmethodID catch_method,
782
     jlocation catch_location);
783

784
typedef void (JNICALL *jvmtiEventExceptionCatch)
785
    (jvmtiEnv *jvmti_env,
786
     JNIEnv* jni_env,
787
     jthread thread,
788
     jmethodID method,
789
     jlocation location,
790
     jobject exception);
791

792
typedef void (JNICALL *jvmtiEventFieldAccess)
793
    (jvmtiEnv *jvmti_env,
794
     JNIEnv* jni_env,
795
     jthread thread,
796
     jmethodID method,
797
     jlocation location,
798
     jclass field_klass,
799
     jobject object,
800
     jfieldID field);
801

802
typedef void (JNICALL *jvmtiEventFieldModification)
803
    (jvmtiEnv *jvmti_env,
804
     JNIEnv* jni_env,
805
     jthread thread,
806
     jmethodID method,
807
     jlocation location,
808
     jclass field_klass,
809
     jobject object,
810
     jfieldID field,
811
     char signature_type,
812
     jvalue new_value);
813

814
typedef void (JNICALL *jvmtiEventFramePop)
815
    (jvmtiEnv *jvmti_env,
816
     JNIEnv* jni_env,
817
     jthread thread,
818
     jmethodID method,
819
     jboolean was_popped_by_exception);
820

821
typedef void (JNICALL *jvmtiEventGarbageCollectionFinish)
822
    (jvmtiEnv *jvmti_env);
823

824
typedef void (JNICALL *jvmtiEventGarbageCollectionStart)
825
    (jvmtiEnv *jvmti_env);
826

827
typedef void (JNICALL *jvmtiEventMethodEntry)
828
    (jvmtiEnv *jvmti_env,
829
     JNIEnv* jni_env,
830
     jthread thread,
831
     jmethodID method);
832

833
typedef void (JNICALL *jvmtiEventMethodExit)
834
    (jvmtiEnv *jvmti_env,
835
     JNIEnv* jni_env,
836
     jthread thread,
837
     jmethodID method,
838
     jboolean was_popped_by_exception,
839
     jvalue return_value);
840

841
typedef void (JNICALL *jvmtiEventMonitorContendedEnter)
842
    (jvmtiEnv *jvmti_env,
843
     JNIEnv* jni_env,
844
     jthread thread,
845
     jobject object);
846

847
typedef void (JNICALL *jvmtiEventMonitorContendedEntered)
848
    (jvmtiEnv *jvmti_env,
849
     JNIEnv* jni_env,
850
     jthread thread,
851
     jobject object);
852

853
typedef void (JNICALL *jvmtiEventMonitorWait)
854
    (jvmtiEnv *jvmti_env,
855
     JNIEnv* jni_env,
856
     jthread thread,
857
     jobject object,
858
     jlong timeout);
859

860
typedef void (JNICALL *jvmtiEventMonitorWaited)
861
    (jvmtiEnv *jvmti_env,
862
     JNIEnv* jni_env,
863
     jthread thread,
864
     jobject object,
865
     jboolean timed_out);
866

867
typedef void (JNICALL *jvmtiEventNativeMethodBind)
868
    (jvmtiEnv *jvmti_env,
869
     JNIEnv* jni_env,
870
     jthread thread,
871
     jmethodID method,
872
     void* address,
873
     void** new_address_ptr);
874

875
typedef void (JNICALL *jvmtiEventObjectFree)
876
    (jvmtiEnv *jvmti_env,
877
     jlong tag);
878

879
typedef void (JNICALL *jvmtiEventResourceExhausted)
880
    (jvmtiEnv *jvmti_env,
881
     JNIEnv* jni_env,
882
     jint flags,
883
     const void* reserved,
884
     const char* description);
885

886
typedef void (JNICALL *jvmtiEventSingleStep)
887
    (jvmtiEnv *jvmti_env,
888
     JNIEnv* jni_env,
889
     jthread thread,
890
     jmethodID method,
891
     jlocation location);
892

893
typedef void (JNICALL *jvmtiEventThreadEnd)
894
    (jvmtiEnv *jvmti_env,
895
     JNIEnv* jni_env,
896
     jthread thread);
897

898
typedef void (JNICALL *jvmtiEventThreadStart)
899
    (jvmtiEnv *jvmti_env,
900
     JNIEnv* jni_env,
901
     jthread thread);
902

903
typedef void (JNICALL *jvmtiEventVMDeath)
904
    (jvmtiEnv *jvmti_env,
905
     JNIEnv* jni_env);
906

907
typedef void (JNICALL *jvmtiEventVMInit)
908
    (jvmtiEnv *jvmti_env,
909
     JNIEnv* jni_env,
910
     jthread thread);
911

912
typedef void (JNICALL *jvmtiEventVMObjectAlloc)
913
    (jvmtiEnv *jvmti_env,
914
     JNIEnv* jni_env,
915
     jthread thread,
916
     jobject object,
917
     jclass object_klass,
918
     jlong size);
919

920
typedef void (JNICALL *jvmtiEventVMStart)
921
    (jvmtiEnv *jvmti_env,
922
     JNIEnv* jni_env);
923

924
    /* Event Callback Structure */
925

926
typedef struct {
927
                              /*   50 : VM Initialization Event */
928
    jvmtiEventVMInit VMInit;
929
                              /*   51 : VM Death Event */
930
    jvmtiEventVMDeath VMDeath;
931
                              /*   52 : Thread Start */
932
    jvmtiEventThreadStart ThreadStart;
933
                              /*   53 : Thread End */
934
    jvmtiEventThreadEnd ThreadEnd;
935
                              /*   54 : Class File Load Hook */
936
    jvmtiEventClassFileLoadHook ClassFileLoadHook;
937
                              /*   55 : Class Load */
938
    jvmtiEventClassLoad ClassLoad;
939
                              /*   56 : Class Prepare */
940
    jvmtiEventClassPrepare ClassPrepare;
941
                              /*   57 : VM Start Event */
942
    jvmtiEventVMStart VMStart;
943
                              /*   58 : Exception */
944
    jvmtiEventException Exception;
945
                              /*   59 : Exception Catch */
946
    jvmtiEventExceptionCatch ExceptionCatch;
947
                              /*   60 : Single Step */
948
    jvmtiEventSingleStep SingleStep;
949
                              /*   61 : Frame Pop */
950
    jvmtiEventFramePop FramePop;
951
                              /*   62 : Breakpoint */
952
    jvmtiEventBreakpoint Breakpoint;
953
                              /*   63 : Field Access */
954
    jvmtiEventFieldAccess FieldAccess;
955
                              /*   64 : Field Modification */
956
    jvmtiEventFieldModification FieldModification;
957
                              /*   65 : Method Entry */
958
    jvmtiEventMethodEntry MethodEntry;
959
                              /*   66 : Method Exit */
960
    jvmtiEventMethodExit MethodExit;
961
                              /*   67 : Native Method Bind */
962
    jvmtiEventNativeMethodBind NativeMethodBind;
963
                              /*   68 : Compiled Method Load */
964
    jvmtiEventCompiledMethodLoad CompiledMethodLoad;
965
                              /*   69 : Compiled Method Unload */
966
    jvmtiEventCompiledMethodUnload CompiledMethodUnload;
967
                              /*   70 : Dynamic Code Generated */
968
    jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
969
                              /*   71 : Data Dump Request */
970
    jvmtiEventDataDumpRequest DataDumpRequest;
971
                              /*   72 */
972
    jvmtiEventReserved reserved72;
973
                              /*   73 : Monitor Wait */
974
    jvmtiEventMonitorWait MonitorWait;
975
                              /*   74 : Monitor Waited */
976
    jvmtiEventMonitorWaited MonitorWaited;
977
                              /*   75 : Monitor Contended Enter */
978
    jvmtiEventMonitorContendedEnter MonitorContendedEnter;
979
                              /*   76 : Monitor Contended Entered */
980
    jvmtiEventMonitorContendedEntered MonitorContendedEntered;
981
                              /*   77 */
982
    jvmtiEventReserved reserved77;
983
                              /*   78 */
984
    jvmtiEventReserved reserved78;
985
                              /*   79 */
986
    jvmtiEventReserved reserved79;
987
                              /*   80 : Resource Exhausted */
988
    jvmtiEventResourceExhausted ResourceExhausted;
989
                              /*   81 : Garbage Collection Start */
990
    jvmtiEventGarbageCollectionStart GarbageCollectionStart;
991
                              /*   82 : Garbage Collection Finish */
992
    jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
993
                              /*   83 : Object Free */
994
    jvmtiEventObjectFree ObjectFree;
995
                              /*   84 : VM Object Allocation */
996
    jvmtiEventVMObjectAlloc VMObjectAlloc;
997
} jvmtiEventCallbacks;
998

999

1000
    /* Function Interface */
1001

1002
typedef struct jvmtiInterface_1_ {
1003

1004
  /*   1 :  RESERVED */
1005
  void *reserved1;
1006

1007
  /*   2 : Set Event Notification Mode */
1008
  jvmtiError (JNICALL *SetEventNotificationMode) (jvmtiEnv* env,
1009
    jvmtiEventMode mode,
1010
    jvmtiEvent event_type,
1011
    jthread event_thread,
1012
     ...);
1013

1014
  /*   3 :  RESERVED */
1015
  void *reserved3;
1016

1017
  /*   4 : Get All Threads */
1018
  jvmtiError (JNICALL *GetAllThreads) (jvmtiEnv* env,
1019
    jint* threads_count_ptr,
1020
    jthread** threads_ptr);
1021

1022
  /*   5 : Suspend Thread */
1023
  jvmtiError (JNICALL *SuspendThread) (jvmtiEnv* env,
1024
    jthread thread);
1025

1026
  /*   6 : Resume Thread */
1027
  jvmtiError (JNICALL *ResumeThread) (jvmtiEnv* env,
1028
    jthread thread);
1029

1030
  /*   7 : Stop Thread */
1031
  jvmtiError (JNICALL *StopThread) (jvmtiEnv* env,
1032
    jthread thread,
1033
    jobject exception);
1034

1035
  /*   8 : Interrupt Thread */
1036
  jvmtiError (JNICALL *InterruptThread) (jvmtiEnv* env,
1037
    jthread thread);
1038

1039
  /*   9 : Get Thread Info */
1040
  jvmtiError (JNICALL *GetThreadInfo) (jvmtiEnv* env,
1041
    jthread thread,
1042
    jvmtiThreadInfo* info_ptr);
1043

1044
  /*   10 : Get Owned Monitor Info */
1045
  jvmtiError (JNICALL *GetOwnedMonitorInfo) (jvmtiEnv* env,
1046
    jthread thread,
1047
    jint* owned_monitor_count_ptr,
1048
    jobject** owned_monitors_ptr);
1049

1050
  /*   11 : Get Current Contended Monitor */
1051
  jvmtiError (JNICALL *GetCurrentContendedMonitor) (jvmtiEnv* env,
1052
    jthread thread,
1053
    jobject* monitor_ptr);
1054

1055
  /*   12 : Run Agent Thread */
1056
  jvmtiError (JNICALL *RunAgentThread) (jvmtiEnv* env,
1057
    jthread thread,
1058
    jvmtiStartFunction proc,
1059
    const void* arg,
1060
    jint priority);
1061

1062
  /*   13 : Get Top Thread Groups */
1063
  jvmtiError (JNICALL *GetTopThreadGroups) (jvmtiEnv* env,
1064
    jint* group_count_ptr,
1065
    jthreadGroup** groups_ptr);
1066

1067
  /*   14 : Get Thread Group Info */
1068
  jvmtiError (JNICALL *GetThreadGroupInfo) (jvmtiEnv* env,
1069
    jthreadGroup group,
1070
    jvmtiThreadGroupInfo* info_ptr);
1071

1072
  /*   15 : Get Thread Group Children */
1073
  jvmtiError (JNICALL *GetThreadGroupChildren) (jvmtiEnv* env,
1074
    jthreadGroup group,
1075
    jint* thread_count_ptr,
1076
    jthread** threads_ptr,
1077
    jint* group_count_ptr,
1078
    jthreadGroup** groups_ptr);
1079

1080
  /*   16 : Get Frame Count */
1081
  jvmtiError (JNICALL *GetFrameCount) (jvmtiEnv* env,
1082
    jthread thread,
1083
    jint* count_ptr);
1084

1085
  /*   17 : Get Thread State */
1086
  jvmtiError (JNICALL *GetThreadState) (jvmtiEnv* env,
1087
    jthread thread,
1088
    jint* thread_state_ptr);
1089

1090
  /*   18 : Get Current Thread */
1091
  jvmtiError (JNICALL *GetCurrentThread) (jvmtiEnv* env,
1092
    jthread* thread_ptr);
1093

1094
  /*   19 : Get Frame Location */
1095
  jvmtiError (JNICALL *GetFrameLocation) (jvmtiEnv* env,
1096
    jthread thread,
1097
    jint depth,
1098
    jmethodID* method_ptr,
1099
    jlocation* location_ptr);
1100

1101
  /*   20 : Notify Frame Pop */
1102
  jvmtiError (JNICALL *NotifyFramePop) (jvmtiEnv* env,
1103
    jthread thread,
1104
    jint depth);
1105

1106
  /*   21 : Get Local Variable - Object */
1107
  jvmtiError (JNICALL *GetLocalObject) (jvmtiEnv* env,
1108
    jthread thread,
1109
    jint depth,
1110
    jint slot,
1111
    jobject* value_ptr);
1112

1113
  /*   22 : Get Local Variable - Int */
1114
  jvmtiError (JNICALL *GetLocalInt) (jvmtiEnv* env,
1115
    jthread thread,
1116
    jint depth,
1117
    jint slot,
1118
    jint* value_ptr);
1119

1120
  /*   23 : Get Local Variable - Long */
1121
  jvmtiError (JNICALL *GetLocalLong) (jvmtiEnv* env,
1122
    jthread thread,
1123
    jint depth,
1124
    jint slot,
1125
    jlong* value_ptr);
1126

1127
  /*   24 : Get Local Variable - Float */
1128
  jvmtiError (JNICALL *GetLocalFloat) (jvmtiEnv* env,
1129
    jthread thread,
1130
    jint depth,
1131
    jint slot,
1132
    jfloat* value_ptr);
1133

1134
  /*   25 : Get Local Variable - Double */
1135
  jvmtiError (JNICALL *GetLocalDouble) (jvmtiEnv* env,
1136
    jthread thread,
1137
    jint depth,
1138
    jint slot,
1139
    jdouble* value_ptr);
1140

1141
  /*   26 : Set Local Variable - Object */
1142
  jvmtiError (JNICALL *SetLocalObject) (jvmtiEnv* env,
1143
    jthread thread,
1144
    jint depth,
1145
    jint slot,
1146
    jobject value);
1147

1148
  /*   27 : Set Local Variable - Int */
1149
  jvmtiError (JNICALL *SetLocalInt) (jvmtiEnv* env,
1150
    jthread thread,
1151
    jint depth,
1152
    jint slot,
1153
    jint value);
1154

1155
  /*   28 : Set Local Variable - Long */
1156
  jvmtiError (JNICALL *SetLocalLong) (jvmtiEnv* env,
1157
    jthread thread,
1158
    jint depth,
1159
    jint slot,
1160
    jlong value);
1161

1162
  /*   29 : Set Local Variable - Float */
1163
  jvmtiError (JNICALL *SetLocalFloat) (jvmtiEnv* env,
1164
    jthread thread,
1165
    jint depth,
1166
    jint slot,
1167
    jfloat value);
1168

1169
  /*   30 : Set Local Variable - Double */
1170
  jvmtiError (JNICALL *SetLocalDouble) (jvmtiEnv* env,
1171
    jthread thread,
1172
    jint depth,
1173
    jint slot,
1174
    jdouble value);
1175

1176
  /*   31 : Create Raw Monitor */
1177
  jvmtiError (JNICALL *CreateRawMonitor) (jvmtiEnv* env,
1178
    const char* name,
1179
    jrawMonitorID* monitor_ptr);
1180

1181
  /*   32 : Destroy Raw Monitor */
1182
  jvmtiError (JNICALL *DestroyRawMonitor) (jvmtiEnv* env,
1183
    jrawMonitorID monitor);
1184

1185
  /*   33 : Raw Monitor Enter */
1186
  jvmtiError (JNICALL *RawMonitorEnter) (jvmtiEnv* env,
1187
    jrawMonitorID monitor);
1188

1189
  /*   34 : Raw Monitor Exit */
1190
  jvmtiError (JNICALL *RawMonitorExit) (jvmtiEnv* env,
1191
    jrawMonitorID monitor);
1192

1193
  /*   35 : Raw Monitor Wait */
1194
  jvmtiError (JNICALL *RawMonitorWait) (jvmtiEnv* env,
1195
    jrawMonitorID monitor,
1196
    jlong millis);
1197

1198
  /*   36 : Raw Monitor Notify */
1199
  jvmtiError (JNICALL *RawMonitorNotify) (jvmtiEnv* env,
1200
    jrawMonitorID monitor);
1201

1202
  /*   37 : Raw Monitor Notify All */
1203
  jvmtiError (JNICALL *RawMonitorNotifyAll) (jvmtiEnv* env,
1204
    jrawMonitorID monitor);
1205

1206
  /*   38 : Set Breakpoint */
1207
  jvmtiError (JNICALL *SetBreakpoint) (jvmtiEnv* env,
1208
    jmethodID method,
1209
    jlocation location);
1210

1211
  /*   39 : Clear Breakpoint */
1212
  jvmtiError (JNICALL *ClearBreakpoint) (jvmtiEnv* env,
1213
    jmethodID method,
1214
    jlocation location);
1215

1216
  /*   40 :  RESERVED */
1217
  void *reserved40;
1218

1219
  /*   41 : Set Field Access Watch */
1220
  jvmtiError (JNICALL *SetFieldAccessWatch) (jvmtiEnv* env,
1221
    jclass klass,
1222
    jfieldID field);
1223

1224
  /*   42 : Clear Field Access Watch */
1225
  jvmtiError (JNICALL *ClearFieldAccessWatch) (jvmtiEnv* env,
1226
    jclass klass,
1227
    jfieldID field);
1228

1229
  /*   43 : Set Field Modification Watch */
1230
  jvmtiError (JNICALL *SetFieldModificationWatch) (jvmtiEnv* env,
1231
    jclass klass,
1232
    jfieldID field);
1233

1234
  /*   44 : Clear Field Modification Watch */
1235
  jvmtiError (JNICALL *ClearFieldModificationWatch) (jvmtiEnv* env,
1236
    jclass klass,
1237
    jfieldID field);
1238

1239
  /*   45 : Is Modifiable Class */
1240
  jvmtiError (JNICALL *IsModifiableClass) (jvmtiEnv* env,
1241
    jclass klass,
1242
    jboolean* is_modifiable_class_ptr);
1243

1244
  /*   46 : Allocate */
1245
  jvmtiError (JNICALL *Allocate) (jvmtiEnv* env,
1246
    jlong size,
1247
    unsigned char** mem_ptr);
1248

1249
  /*   47 : Deallocate */
1250
  jvmtiError (JNICALL *Deallocate) (jvmtiEnv* env,
1251
    unsigned char* mem);
1252

1253
  /*   48 : Get Class Signature */
1254
  jvmtiError (JNICALL *GetClassSignature) (jvmtiEnv* env,
1255
    jclass klass,
1256
    char** signature_ptr,
1257
    char** generic_ptr);
1258

1259
  /*   49 : Get Class Status */
1260
  jvmtiError (JNICALL *GetClassStatus) (jvmtiEnv* env,
1261
    jclass klass,
1262
    jint* status_ptr);
1263

1264
  /*   50 : Get Source File Name */
1265
  jvmtiError (JNICALL *GetSourceFileName) (jvmtiEnv* env,
1266
    jclass klass,
1267
    char** source_name_ptr);
1268

1269
  /*   51 : Get Class Modifiers */
1270
  jvmtiError (JNICALL *GetClassModifiers) (jvmtiEnv* env,
1271
    jclass klass,
1272
    jint* modifiers_ptr);
1273

1274
  /*   52 : Get Class Methods */
1275
  jvmtiError (JNICALL *GetClassMethods) (jvmtiEnv* env,
1276
    jclass klass,
1277
    jint* method_count_ptr,
1278
    jmethodID** methods_ptr);
1279

1280
  /*   53 : Get Class Fields */
1281
  jvmtiError (JNICALL *GetClassFields) (jvmtiEnv* env,
1282
    jclass klass,
1283
    jint* field_count_ptr,
1284
    jfieldID** fields_ptr);
1285

1286
  /*   54 : Get Implemented Interfaces */
1287
  jvmtiError (JNICALL *GetImplementedInterfaces) (jvmtiEnv* env,
1288
    jclass klass,
1289
    jint* interface_count_ptr,
1290
    jclass** interfaces_ptr);
1291

1292
  /*   55 : Is Interface */
1293
  jvmtiError (JNICALL *IsInterface) (jvmtiEnv* env,
1294
    jclass klass,
1295
    jboolean* is_interface_ptr);
1296

1297
  /*   56 : Is Array Class */
1298
  jvmtiError (JNICALL *IsArrayClass) (jvmtiEnv* env,
1299
    jclass klass,
1300
    jboolean* is_array_class_ptr);
1301

1302
  /*   57 : Get Class Loader */
1303
  jvmtiError (JNICALL *GetClassLoader) (jvmtiEnv* env,
1304
    jclass klass,
1305
    jobject* classloader_ptr);
1306

1307
  /*   58 : Get Object Hash Code */
1308
  jvmtiError (JNICALL *GetObjectHashCode) (jvmtiEnv* env,
1309
    jobject object,
1310
    jint* hash_code_ptr);
1311

1312
  /*   59 : Get Object Monitor Usage */
1313
  jvmtiError (JNICALL *GetObjectMonitorUsage) (jvmtiEnv* env,
1314
    jobject object,
1315
    jvmtiMonitorUsage* info_ptr);
1316

1317
  /*   60 : Get Field Name (and Signature) */
1318
  jvmtiError (JNICALL *GetFieldName) (jvmtiEnv* env,
1319
    jclass klass,
1320
    jfieldID field,
1321
    char** name_ptr,
1322
    char** signature_ptr,
1323
    char** generic_ptr);
1324

1325
  /*   61 : Get Field Declaring Class */
1326
  jvmtiError (JNICALL *GetFieldDeclaringClass) (jvmtiEnv* env,
1327
    jclass klass,
1328
    jfieldID field,
1329
    jclass* declaring_class_ptr);
1330

1331
  /*   62 : Get Field Modifiers */
1332
  jvmtiError (JNICALL *GetFieldModifiers) (jvmtiEnv* env,
1333
    jclass klass,
1334
    jfieldID field,
1335
    jint* modifiers_ptr);
1336

1337
  /*   63 : Is Field Synthetic */
1338
  jvmtiError (JNICALL *IsFieldSynthetic) (jvmtiEnv* env,
1339
    jclass klass,
1340
    jfieldID field,
1341
    jboolean* is_synthetic_ptr);
1342

1343
  /*   64 : Get Method Name (and Signature) */
1344
  jvmtiError (JNICALL *GetMethodName) (jvmtiEnv* env,
1345
    jmethodID method,
1346
    char** name_ptr,
1347
    char** signature_ptr,
1348
    char** generic_ptr);
1349

1350
  /*   65 : Get Method Declaring Class */
1351
  jvmtiError (JNICALL *GetMethodDeclaringClass) (jvmtiEnv* env,
1352
    jmethodID method,
1353
    jclass* declaring_class_ptr);
1354

1355
  /*   66 : Get Method Modifiers */
1356
  jvmtiError (JNICALL *GetMethodModifiers) (jvmtiEnv* env,
1357
    jmethodID method,
1358
    jint* modifiers_ptr);
1359

1360
  /*   67 :  RESERVED */
1361
  void *reserved67;
1362

1363
  /*   68 : Get Max Locals */
1364
  jvmtiError (JNICALL *GetMaxLocals) (jvmtiEnv* env,
1365
    jmethodID method,
1366
    jint* max_ptr);
1367

1368
  /*   69 : Get Arguments Size */
1369
  jvmtiError (JNICALL *GetArgumentsSize) (jvmtiEnv* env,
1370
    jmethodID method,
1371
    jint* size_ptr);
1372

1373
  /*   70 : Get Line Number Table */
1374
  jvmtiError (JNICALL *GetLineNumberTable) (jvmtiEnv* env,
1375
    jmethodID method,
1376
    jint* entry_count_ptr,
1377
    jvmtiLineNumberEntry** table_ptr);
1378

1379
  /*   71 : Get Method Location */
1380
  jvmtiError (JNICALL *GetMethodLocation) (jvmtiEnv* env,
1381
    jmethodID method,
1382
    jlocation* start_location_ptr,
1383
    jlocation* end_location_ptr);
1384

1385
  /*   72 : Get Local Variable Table */
1386
  jvmtiError (JNICALL *GetLocalVariableTable) (jvmtiEnv* env,
1387
    jmethodID method,
1388
    jint* entry_count_ptr,
1389
    jvmtiLocalVariableEntry** table_ptr);
1390

1391
  /*   73 : Set Native Method Prefix */
1392
  jvmtiError (JNICALL *SetNativeMethodPrefix) (jvmtiEnv* env,
1393
    const char* prefix);
1394

1395
  /*   74 : Set Native Method Prefixes */
1396
  jvmtiError (JNICALL *SetNativeMethodPrefixes) (jvmtiEnv* env,
1397
    jint prefix_count,
1398
    char** prefixes);
1399

1400
  /*   75 : Get Bytecodes */
1401
  jvmtiError (JNICALL *GetBytecodes) (jvmtiEnv* env,
1402
    jmethodID method,
1403
    jint* bytecode_count_ptr,
1404
    unsigned char** bytecodes_ptr);
1405

1406
  /*   76 : Is Method Native */
1407
  jvmtiError (JNICALL *IsMethodNative) (jvmtiEnv* env,
1408
    jmethodID method,
1409
    jboolean* is_native_ptr);
1410

1411
  /*   77 : Is Method Synthetic */
1412
  jvmtiError (JNICALL *IsMethodSynthetic) (jvmtiEnv* env,
1413
    jmethodID method,
1414
    jboolean* is_synthetic_ptr);
1415

1416
  /*   78 : Get Loaded Classes */
1417
  jvmtiError (JNICALL *GetLoadedClasses) (jvmtiEnv* env,
1418
    jint* class_count_ptr,
1419
    jclass** classes_ptr);
1420

1421
  /*   79 : Get Classloader Classes */
1422
  jvmtiError (JNICALL *GetClassLoaderClasses) (jvmtiEnv* env,
1423
    jobject initiating_loader,
1424
    jint* class_count_ptr,
1425
    jclass** classes_ptr);
1426

1427
  /*   80 : Pop Frame */
1428
  jvmtiError (JNICALL *PopFrame) (jvmtiEnv* env,
1429
    jthread thread);
1430

1431
  /*   81 : Force Early Return - Object */
1432
  jvmtiError (JNICALL *ForceEarlyReturnObject) (jvmtiEnv* env,
1433
    jthread thread,
1434
    jobject value);
1435

1436
  /*   82 : Force Early Return - Int */
1437
  jvmtiError (JNICALL *ForceEarlyReturnInt) (jvmtiEnv* env,
1438
    jthread thread,
1439
    jint value);
1440

1441
  /*   83 : Force Early Return - Long */
1442
  jvmtiError (JNICALL *ForceEarlyReturnLong) (jvmtiEnv* env,
1443
    jthread thread,
1444
    jlong value);
1445

1446
  /*   84 : Force Early Return - Float */
1447
  jvmtiError (JNICALL *ForceEarlyReturnFloat) (jvmtiEnv* env,
1448
    jthread thread,
1449
    jfloat value);
1450

1451
  /*   85 : Force Early Return - Double */
1452
  jvmtiError (JNICALL *ForceEarlyReturnDouble) (jvmtiEnv* env,
1453
    jthread thread,
1454
    jdouble value);
1455

1456
  /*   86 : Force Early Return - Void */
1457
  jvmtiError (JNICALL *ForceEarlyReturnVoid) (jvmtiEnv* env,
1458
    jthread thread);
1459

1460
  /*   87 : Redefine Classes */
1461
  jvmtiError (JNICALL *RedefineClasses) (jvmtiEnv* env,
1462
    jint class_count,
1463
    const jvmtiClassDefinition* class_definitions);
1464

1465
  /*   88 : Get Version Number */
1466
  jvmtiError (JNICALL *GetVersionNumber) (jvmtiEnv* env,
1467
    jint* version_ptr);
1468

1469
  /*   89 : Get Capabilities */
1470
  jvmtiError (JNICALL *GetCapabilities) (jvmtiEnv* env,
1471
    jvmtiCapabilities* capabilities_ptr);
1472

1473
  /*   90 : Get Source Debug Extension */
1474
  jvmtiError (JNICALL *GetSourceDebugExtension) (jvmtiEnv* env,
1475
    jclass klass,
1476
    char** source_debug_extension_ptr);
1477

1478
  /*   91 : Is Method Obsolete */
1479
  jvmtiError (JNICALL *IsMethodObsolete) (jvmtiEnv* env,
1480
    jmethodID method,
1481
    jboolean* is_obsolete_ptr);
1482

1483
  /*   92 : Suspend Thread List */
1484
  jvmtiError (JNICALL *SuspendThreadList) (jvmtiEnv* env,
1485
    jint request_count,
1486
    const jthread* request_list,
1487
    jvmtiError* results);
1488

1489
  /*   93 : Resume Thread List */
1490
  jvmtiError (JNICALL *ResumeThreadList) (jvmtiEnv* env,
1491
    jint request_count,
1492
    const jthread* request_list,
1493
    jvmtiError* results);
1494

1495
  /*   94 :  RESERVED */
1496
  void *reserved94;
1497

1498
  /*   95 :  RESERVED */
1499
  void *reserved95;
1500

1501
  /*   96 :  RESERVED */
1502
  void *reserved96;
1503

1504
  /*   97 :  RESERVED */
1505
  void *reserved97;
1506

1507
  /*   98 :  RESERVED */
1508
  void *reserved98;
1509

1510
  /*   99 :  RESERVED */
1511
  void *reserved99;
1512

1513
  /*   100 : Get All Stack Traces */
1514
  jvmtiError (JNICALL *GetAllStackTraces) (jvmtiEnv* env,
1515
    jint max_frame_count,
1516
    jvmtiStackInfo** stack_info_ptr,
1517
    jint* thread_count_ptr);
1518

1519
  /*   101 : Get Thread List Stack Traces */
1520
  jvmtiError (JNICALL *GetThreadListStackTraces) (jvmtiEnv* env,
1521
    jint thread_count,
1522
    const jthread* thread_list,
1523
    jint max_frame_count,
1524
    jvmtiStackInfo** stack_info_ptr);
1525

1526
  /*   102 : Get Thread Local Storage */
1527
  jvmtiError (JNICALL *GetThreadLocalStorage) (jvmtiEnv* env,
1528
    jthread thread,
1529
    void** data_ptr);
1530

1531
  /*   103 : Set Thread Local Storage */
1532
  jvmtiError (JNICALL *SetThreadLocalStorage) (jvmtiEnv* env,
1533
    jthread thread,
1534
    const void* data);
1535

1536
  /*   104 : Get Stack Trace */
1537
  jvmtiError (JNICALL *GetStackTrace) (jvmtiEnv* env,
1538
    jthread thread,
1539
    jint start_depth,
1540
    jint max_frame_count,
1541
    jvmtiFrameInfo* frame_buffer,
1542
    jint* count_ptr);
1543

1544
  /*   105 :  RESERVED */
1545
  void *reserved105;
1546

1547
  /*   106 : Get Tag */
1548
  jvmtiError (JNICALL *GetTag) (jvmtiEnv* env,
1549
    jobject object,
1550
    jlong* tag_ptr);
1551

1552
  /*   107 : Set Tag */
1553
  jvmtiError (JNICALL *SetTag) (jvmtiEnv* env,
1554
    jobject object,
1555
    jlong tag);
1556

1557
  /*   108 : Force Garbage Collection */
1558
  jvmtiError (JNICALL *ForceGarbageCollection) (jvmtiEnv* env);
1559

1560
  /*   109 : Iterate Over Objects Reachable From Object */
1561
  jvmtiError (JNICALL *IterateOverObjectsReachableFromObject) (jvmtiEnv* env,
1562
    jobject object,
1563
    jvmtiObjectReferenceCallback object_reference_callback,
1564
    const void* user_data);
1565

1566
  /*   110 : Iterate Over Reachable Objects */
1567
  jvmtiError (JNICALL *IterateOverReachableObjects) (jvmtiEnv* env,
1568
    jvmtiHeapRootCallback heap_root_callback,
1569
    jvmtiStackReferenceCallback stack_ref_callback,
1570
    jvmtiObjectReferenceCallback object_ref_callback,
1571
    const void* user_data);
1572

1573
  /*   111 : Iterate Over Heap */
1574
  jvmtiError (JNICALL *IterateOverHeap) (jvmtiEnv* env,
1575
    jvmtiHeapObjectFilter object_filter,
1576
    jvmtiHeapObjectCallback heap_object_callback,
1577
    const void* user_data);
1578

1579
  /*   112 : Iterate Over Instances Of Class */
1580
  jvmtiError (JNICALL *IterateOverInstancesOfClass) (jvmtiEnv* env,
1581
    jclass klass,
1582
    jvmtiHeapObjectFilter object_filter,
1583
    jvmtiHeapObjectCallback heap_object_callback,
1584
    const void* user_data);
1585

1586
  /*   113 :  RESERVED */
1587
  void *reserved113;
1588

1589
  /*   114 : Get Objects With Tags */
1590
  jvmtiError (JNICALL *GetObjectsWithTags) (jvmtiEnv* env,
1591
    jint tag_count,
1592
    const jlong* tags,
1593
    jint* count_ptr,
1594
    jobject** object_result_ptr,
1595
    jlong** tag_result_ptr);
1596

1597
  /*   115 : Follow References */
1598
  jvmtiError (JNICALL *FollowReferences) (jvmtiEnv* env,
1599
    jint heap_filter,
1600
    jclass klass,
1601
    jobject initial_object,
1602
    const jvmtiHeapCallbacks* callbacks,
1603
    const void* user_data);
1604

1605
  /*   116 : Iterate Through Heap */
1606
  jvmtiError (JNICALL *IterateThroughHeap) (jvmtiEnv* env,
1607
    jint heap_filter,
1608
    jclass klass,
1609
    const jvmtiHeapCallbacks* callbacks,
1610
    const void* user_data);
1611

1612
  /*   117 :  RESERVED */
1613
  void *reserved117;
1614

1615
  /*   118 :  RESERVED */
1616
  void *reserved118;
1617

1618
  /*   119 :  RESERVED */
1619
  void *reserved119;
1620

1621
  /*   120 : Set JNI Function Table */
1622
  jvmtiError (JNICALL *SetJNIFunctionTable) (jvmtiEnv* env,
1623
    const jniNativeInterface* function_table);
1624

1625
  /*   121 : Get JNI Function Table */
1626
  jvmtiError (JNICALL *GetJNIFunctionTable) (jvmtiEnv* env,
1627
    jniNativeInterface** function_table);
1628

1629
  /*   122 : Set Event Callbacks */
1630
  jvmtiError (JNICALL *SetEventCallbacks) (jvmtiEnv* env,
1631
    const jvmtiEventCallbacks* callbacks,
1632
    jint size_of_callbacks);
1633

1634
  /*   123 : Generate Events */
1635
  jvmtiError (JNICALL *GenerateEvents) (jvmtiEnv* env,
1636
    jvmtiEvent event_type);
1637

1638
  /*   124 : Get Extension Functions */
1639
  jvmtiError (JNICALL *GetExtensionFunctions) (jvmtiEnv* env,
1640
    jint* extension_count_ptr,
1641
    jvmtiExtensionFunctionInfo** extensions);
1642

1643
  /*   125 : Get Extension Events */
1644
  jvmtiError (JNICALL *GetExtensionEvents) (jvmtiEnv* env,
1645
    jint* extension_count_ptr,
1646
    jvmtiExtensionEventInfo** extensions);
1647

1648
  /*   126 : Set Extension Event Callback */
1649
  jvmtiError (JNICALL *SetExtensionEventCallback) (jvmtiEnv* env,
1650
    jint extension_event_index,
1651
    jvmtiExtensionEvent callback);
1652

1653
  /*   127 : Dispose Environment */
1654
  jvmtiError (JNICALL *DisposeEnvironment) (jvmtiEnv* env);
1655

1656
  /*   128 : Get Error Name */
1657
  jvmtiError (JNICALL *GetErrorName) (jvmtiEnv* env,
1658
    jvmtiError error,
1659
    char** name_ptr);
1660

1661
  /*   129 : Get JLocation Format */
1662
  jvmtiError (JNICALL *GetJLocationFormat) (jvmtiEnv* env,
1663
    jvmtiJlocationFormat* format_ptr);
1664

1665
  /*   130 : Get System Properties */
1666
  jvmtiError (JNICALL *GetSystemProperties) (jvmtiEnv* env,
1667
    jint* count_ptr,
1668
    char*** property_ptr);
1669

1670
  /*   131 : Get System Property */
1671
  jvmtiError (JNICALL *GetSystemProperty) (jvmtiEnv* env,
1672
    const char* property,
1673
    char** value_ptr);
1674

1675
  /*   132 : Set System Property */
1676
  jvmtiError (JNICALL *SetSystemProperty) (jvmtiEnv* env,
1677
    const char* property,
1678
    const char* value);
1679

1680
  /*   133 : Get Phase */
1681
  jvmtiError (JNICALL *GetPhase) (jvmtiEnv* env,
1682
    jvmtiPhase* phase_ptr);
1683

1684
  /*   134 : Get Current Thread CPU Timer Information */
1685
  jvmtiError (JNICALL *GetCurrentThreadCpuTimerInfo) (jvmtiEnv* env,
1686
    jvmtiTimerInfo* info_ptr);
1687

1688
  /*   135 : Get Current Thread CPU Time */
1689
  jvmtiError (JNICALL *GetCurrentThreadCpuTime) (jvmtiEnv* env,
1690
    jlong* nanos_ptr);
1691

1692
  /*   136 : Get Thread CPU Timer Information */
1693
  jvmtiError (JNICALL *GetThreadCpuTimerInfo) (jvmtiEnv* env,
1694
    jvmtiTimerInfo* info_ptr);
1695

1696
  /*   137 : Get Thread CPU Time */
1697
  jvmtiError (JNICALL *GetThreadCpuTime) (jvmtiEnv* env,
1698
    jthread thread,
1699
    jlong* nanos_ptr);
1700

1701
  /*   138 : Get Timer Information */
1702
  jvmtiError (JNICALL *GetTimerInfo) (jvmtiEnv* env,
1703
    jvmtiTimerInfo* info_ptr);
1704

1705
  /*   139 : Get Time */
1706
  jvmtiError (JNICALL *GetTime) (jvmtiEnv* env,
1707
    jlong* nanos_ptr);
1708

1709
  /*   140 : Get Potential Capabilities */
1710
  jvmtiError (JNICALL *GetPotentialCapabilities) (jvmtiEnv* env,
1711
    jvmtiCapabilities* capabilities_ptr);
1712

1713
  /*   141 :  RESERVED */
1714
  void *reserved141;
1715

1716
  /*   142 : Add Capabilities */
1717
  jvmtiError (JNICALL *AddCapabilities) (jvmtiEnv* env,
1718
    const jvmtiCapabilities* capabilities_ptr);
1719

1720
  /*   143 : Relinquish Capabilities */
1721
  jvmtiError (JNICALL *RelinquishCapabilities) (jvmtiEnv* env,
1722
    const jvmtiCapabilities* capabilities_ptr);
1723

1724
  /*   144 : Get Available Processors */
1725
  jvmtiError (JNICALL *GetAvailableProcessors) (jvmtiEnv* env,
1726
    jint* processor_count_ptr);
1727

1728
  /*   145 : Get Class Version Numbers */
1729
  jvmtiError (JNICALL *GetClassVersionNumbers) (jvmtiEnv* env,
1730
    jclass klass,
1731
    jint* minor_version_ptr,
1732
    jint* major_version_ptr);
1733

1734
  /*   146 : Get Constant Pool */
1735
  jvmtiError (JNICALL *GetConstantPool) (jvmtiEnv* env,
1736
    jclass klass,
1737
    jint* constant_pool_count_ptr,
1738
    jint* constant_pool_byte_count_ptr,
1739
    unsigned char** constant_pool_bytes_ptr);
1740

1741
  /*   147 : Get Environment Local Storage */
1742
  jvmtiError (JNICALL *GetEnvironmentLocalStorage) (jvmtiEnv* env,
1743
    void** data_ptr);
1744

1745
  /*   148 : Set Environment Local Storage */
1746
  jvmtiError (JNICALL *SetEnvironmentLocalStorage) (jvmtiEnv* env,
1747
    const void* data);
1748

1749
  /*   149 : Add To Bootstrap Class Loader Search */
1750
  jvmtiError (JNICALL *AddToBootstrapClassLoaderSearch) (jvmtiEnv* env,
1751
    const char* segment);
1752

1753
  /*   150 : Set Verbose Flag */
1754
  jvmtiError (JNICALL *SetVerboseFlag) (jvmtiEnv* env,
1755
    jvmtiVerboseFlag flag,
1756
    jboolean value);
1757

1758
  /*   151 : Add To System Class Loader Search */
1759
  jvmtiError (JNICALL *AddToSystemClassLoaderSearch) (jvmtiEnv* env,
1760
    const char* segment);
1761

1762
  /*   152 : Retransform Classes */
1763
  jvmtiError (JNICALL *RetransformClasses) (jvmtiEnv* env,
1764
    jint class_count,
1765
    const jclass* classes);
1766

1767
  /*   153 : Get Owned Monitor Stack Depth Info */
1768
  jvmtiError (JNICALL *GetOwnedMonitorStackDepthInfo) (jvmtiEnv* env,
1769
    jthread thread,
1770
    jint* monitor_info_count_ptr,
1771
    jvmtiMonitorStackDepthInfo** monitor_info_ptr);
1772

1773
  /*   154 : Get Object Size */
1774
  jvmtiError (JNICALL *GetObjectSize) (jvmtiEnv* env,
1775
    jobject object,
1776
    jlong* size_ptr);
1777

1778
  /*   155 : Get Local Instance */
1779
  jvmtiError (JNICALL *GetLocalInstance) (jvmtiEnv* env,
1780
    jthread thread,
1781
    jint depth,
1782
    jobject* value_ptr);
1783

1784
} jvmtiInterface_1;
1785

1786
struct _jvmtiEnv {
1787
    const struct jvmtiInterface_1_ *functions;
1788
#ifdef __cplusplus
1789

1790

1791
  jvmtiError Allocate(jlong size,
1792
            unsigned char** mem_ptr) {
1793
    return functions->Allocate(this, size, mem_ptr);
1794
  }
1795

1796
  jvmtiError Deallocate(unsigned char* mem) {
1797
    return functions->Deallocate(this, mem);
1798
  }
1799

1800
  jvmtiError GetThreadState(jthread thread,
1801
            jint* thread_state_ptr) {
1802
    return functions->GetThreadState(this, thread, thread_state_ptr);
1803
  }
1804

1805
  jvmtiError GetCurrentThread(jthread* thread_ptr) {
1806
    return functions->GetCurrentThread(this, thread_ptr);
1807
  }
1808

1809
  jvmtiError GetAllThreads(jint* threads_count_ptr,
1810
            jthread** threads_ptr) {
1811
    return functions->GetAllThreads(this, threads_count_ptr, threads_ptr);
1812
  }
1813

1814
  jvmtiError SuspendThread(jthread thread) {
1815
    return functions->SuspendThread(this, thread);
1816
  }
1817

1818
  jvmtiError SuspendThreadList(jint request_count,
1819
            const jthread* request_list,
1820
            jvmtiError* results) {
1821
    return functions->SuspendThreadList(this, request_count, request_list, results);
1822
  }
1823

1824
  jvmtiError ResumeThread(jthread thread) {
1825
    return functions->ResumeThread(this, thread);
1826
  }
1827

1828
  jvmtiError ResumeThreadList(jint request_count,
1829
            const jthread* request_list,
1830
            jvmtiError* results) {
1831
    return functions->ResumeThreadList(this, request_count, request_list, results);
1832
  }
1833

1834
  jvmtiError StopThread(jthread thread,
1835
            jobject exception) {
1836
    return functions->StopThread(this, thread, exception);
1837
  }
1838

1839
  jvmtiError InterruptThread(jthread thread) {
1840
    return functions->InterruptThread(this, thread);
1841
  }
1842

1843
  jvmtiError GetThreadInfo(jthread thread,
1844
            jvmtiThreadInfo* info_ptr) {
1845
    return functions->GetThreadInfo(this, thread, info_ptr);
1846
  }
1847

1848
  jvmtiError GetOwnedMonitorInfo(jthread thread,
1849
            jint* owned_monitor_count_ptr,
1850
            jobject** owned_monitors_ptr) {
1851
    return functions->GetOwnedMonitorInfo(this, thread, owned_monitor_count_ptr, owned_monitors_ptr);
1852
  }
1853

1854
  jvmtiError GetOwnedMonitorStackDepthInfo(jthread thread,
1855
            jint* monitor_info_count_ptr,
1856
            jvmtiMonitorStackDepthInfo** monitor_info_ptr) {
1857
    return functions->GetOwnedMonitorStackDepthInfo(this, thread, monitor_info_count_ptr, monitor_info_ptr);
1858
  }
1859

1860
  jvmtiError GetCurrentContendedMonitor(jthread thread,
1861
            jobject* monitor_ptr) {
1862
    return functions->GetCurrentContendedMonitor(this, thread, monitor_ptr);
1863
  }
1864

1865
  jvmtiError RunAgentThread(jthread thread,
1866
            jvmtiStartFunction proc,
1867
            const void* arg,
1868
            jint priority) {
1869
    return functions->RunAgentThread(this, thread, proc, arg, priority);
1870
  }
1871

1872
  jvmtiError SetThreadLocalStorage(jthread thread,
1873
            const void* data) {
1874
    return functions->SetThreadLocalStorage(this, thread, data);
1875
  }
1876

1877
  jvmtiError GetThreadLocalStorage(jthread thread,
1878
            void** data_ptr) {
1879
    return functions->GetThreadLocalStorage(this, thread, data_ptr);
1880
  }
1881

1882
  jvmtiError GetTopThreadGroups(jint* group_count_ptr,
1883
            jthreadGroup** groups_ptr) {
1884
    return functions->GetTopThreadGroups(this, group_count_ptr, groups_ptr);
1885
  }
1886

1887
  jvmtiError GetThreadGroupInfo(jthreadGroup group,
1888
            jvmtiThreadGroupInfo* info_ptr) {
1889
    return functions->GetThreadGroupInfo(this, group, info_ptr);
1890
  }
1891

1892
  jvmtiError GetThreadGroupChildren(jthreadGroup group,
1893
            jint* thread_count_ptr,
1894
            jthread** threads_ptr,
1895
            jint* group_count_ptr,
1896
            jthreadGroup** groups_ptr) {
1897
    return functions->GetThreadGroupChildren(this, group, thread_count_ptr, threads_ptr, group_count_ptr, groups_ptr);
1898
  }
1899

1900
  jvmtiError GetStackTrace(jthread thread,
1901
            jint start_depth,
1902
            jint max_frame_count,
1903
            jvmtiFrameInfo* frame_buffer,
1904
            jint* count_ptr) {
1905
    return functions->GetStackTrace(this, thread, start_depth, max_frame_count, frame_buffer, count_ptr);
1906
  }
1907

1908
  jvmtiError GetAllStackTraces(jint max_frame_count,
1909
            jvmtiStackInfo** stack_info_ptr,
1910
            jint* thread_count_ptr) {
1911
    return functions->GetAllStackTraces(this, max_frame_count, stack_info_ptr, thread_count_ptr);
1912
  }
1913

1914
  jvmtiError GetThreadListStackTraces(jint thread_count,
1915
            const jthread* thread_list,
1916
            jint max_frame_count,
1917
            jvmtiStackInfo** stack_info_ptr) {
1918
    return functions->GetThreadListStackTraces(this, thread_count, thread_list, max_frame_count, stack_info_ptr);
1919
  }
1920

1921
  jvmtiError GetFrameCount(jthread thread,
1922
            jint* count_ptr) {
1923
    return functions->GetFrameCount(this, thread, count_ptr);
1924
  }
1925

1926
  jvmtiError PopFrame(jthread thread) {
1927
    return functions->PopFrame(this, thread);
1928
  }
1929

1930
  jvmtiError GetFrameLocation(jthread thread,
1931
            jint depth,
1932
            jmethodID* method_ptr,
1933
            jlocation* location_ptr) {
1934
    return functions->GetFrameLocation(this, thread, depth, method_ptr, location_ptr);
1935
  }
1936

1937
  jvmtiError NotifyFramePop(jthread thread,
1938
            jint depth) {
1939
    return functions->NotifyFramePop(this, thread, depth);
1940
  }
1941

1942
  jvmtiError ForceEarlyReturnObject(jthread thread,
1943
            jobject value) {
1944
    return functions->ForceEarlyReturnObject(this, thread, value);
1945
  }
1946

1947
  jvmtiError ForceEarlyReturnInt(jthread thread,
1948
            jint value) {
1949
    return functions->ForceEarlyReturnInt(this, thread, value);
1950
  }
1951

1952
  jvmtiError ForceEarlyReturnLong(jthread thread,
1953
            jlong value) {
1954
    return functions->ForceEarlyReturnLong(this, thread, value);
1955
  }
1956

1957
  jvmtiError ForceEarlyReturnFloat(jthread thread,
1958
            jfloat value) {
1959
    return functions->ForceEarlyReturnFloat(this, thread, value);
1960
  }
1961

1962
  jvmtiError ForceEarlyReturnDouble(jthread thread,
1963
            jdouble value) {
1964
    return functions->ForceEarlyReturnDouble(this, thread, value);
1965
  }
1966

1967
  jvmtiError ForceEarlyReturnVoid(jthread thread) {
1968
    return functions->ForceEarlyReturnVoid(this, thread);
1969
  }
1970

1971
  jvmtiError FollowReferences(jint heap_filter,
1972
            jclass klass,
1973
            jobject initial_object,
1974
            const jvmtiHeapCallbacks* callbacks,
1975
            const void* user_data) {
1976
    return functions->FollowReferences(this, heap_filter, klass, initial_object, callbacks, user_data);
1977
  }
1978

1979
  jvmtiError IterateThroughHeap(jint heap_filter,
1980
            jclass klass,
1981
            const jvmtiHeapCallbacks* callbacks,
1982
            const void* user_data) {
1983
    return functions->IterateThroughHeap(this, heap_filter, klass, callbacks, user_data);
1984
  }
1985

1986
  jvmtiError GetTag(jobject object,
1987
            jlong* tag_ptr) {
1988
    return functions->GetTag(this, object, tag_ptr);
1989
  }
1990

1991
  jvmtiError SetTag(jobject object,
1992
            jlong tag) {
1993
    return functions->SetTag(this, object, tag);
1994
  }
1995

1996
  jvmtiError GetObjectsWithTags(jint tag_count,
1997
            const jlong* tags,
1998
            jint* count_ptr,
1999
            jobject** object_result_ptr,
2000
            jlong** tag_result_ptr) {
2001
    return functions->GetObjectsWithTags(this, tag_count, tags, count_ptr, object_result_ptr, tag_result_ptr);
2002
  }
2003

2004
  jvmtiError ForceGarbageCollection() {
2005
    return functions->ForceGarbageCollection(this);
2006
  }
2007

2008
  jvmtiError IterateOverObjectsReachableFromObject(jobject object,
2009
            jvmtiObjectReferenceCallback object_reference_callback,
2010
            const void* user_data) {
2011
    return functions->IterateOverObjectsReachableFromObject(this, object, object_reference_callback, user_data);
2012
  }
2013

2014
  jvmtiError IterateOverReachableObjects(jvmtiHeapRootCallback heap_root_callback,
2015
            jvmtiStackReferenceCallback stack_ref_callback,
2016
            jvmtiObjectReferenceCallback object_ref_callback,
2017
            const void* user_data) {
2018
    return functions->IterateOverReachableObjects(this, heap_root_callback, stack_ref_callback, object_ref_callback, user_data);
2019
  }
2020

2021
  jvmtiError IterateOverHeap(jvmtiHeapObjectFilter object_filter,
2022
            jvmtiHeapObjectCallback heap_object_callback,
2023
            const void* user_data) {
2024
    return functions->IterateOverHeap(this, object_filter, heap_object_callback, user_data);
2025
  }
2026

2027
  jvmtiError IterateOverInstancesOfClass(jclass klass,
2028
            jvmtiHeapObjectFilter object_filter,
2029
            jvmtiHeapObjectCallback heap_object_callback,
2030
            const void* user_data) {
2031
    return functions->IterateOverInstancesOfClass(this, klass, object_filter, heap_object_callback, user_data);
2032
  }
2033

2034
  jvmtiError GetLocalObject(jthread thread,
2035
            jint depth,
2036
            jint slot,
2037
            jobject* value_ptr) {
2038
    return functions->GetLocalObject(this, thread, depth, slot, value_ptr);
2039
  }
2040

2041
  jvmtiError GetLocalInstance(jthread thread,
2042
            jint depth,
2043
            jobject* value_ptr) {
2044
    return functions->GetLocalInstance(this, thread, depth, value_ptr);
2045
  }
2046

2047
  jvmtiError GetLocalInt(jthread thread,
2048
            jint depth,
2049
            jint slot,
2050
            jint* value_ptr) {
2051
    return functions->GetLocalInt(this, thread, depth, slot, value_ptr);
2052
  }
2053

2054
  jvmtiError GetLocalLong(jthread thread,
2055
            jint depth,
2056
            jint slot,
2057
            jlong* value_ptr) {
2058
    return functions->GetLocalLong(this, thread, depth, slot, value_ptr);
2059
  }
2060

2061
  jvmtiError GetLocalFloat(jthread thread,
2062
            jint depth,
2063
            jint slot,
2064
            jfloat* value_ptr) {
2065
    return functions->GetLocalFloat(this, thread, depth, slot, value_ptr);
2066
  }
2067

2068
  jvmtiError GetLocalDouble(jthread thread,
2069
            jint depth,
2070
            jint slot,
2071
            jdouble* value_ptr) {
2072
    return functions->GetLocalDouble(this, thread, depth, slot, value_ptr);
2073
  }
2074

2075
  jvmtiError SetLocalObject(jthread thread,
2076
            jint depth,
2077
            jint slot,
2078
            jobject value) {
2079
    return functions->SetLocalObject(this, thread, depth, slot, value);
2080
  }
2081

2082
  jvmtiError SetLocalInt(jthread thread,
2083
            jint depth,
2084
            jint slot,
2085
            jint value) {
2086
    return functions->SetLocalInt(this, thread, depth, slot, value);
2087
  }
2088

2089
  jvmtiError SetLocalLong(jthread thread,
2090
            jint depth,
2091
            jint slot,
2092
            jlong value) {
2093
    return functions->SetLocalLong(this, thread, depth, slot, value);
2094
  }
2095

2096
  jvmtiError SetLocalFloat(jthread thread,
2097
            jint depth,
2098
            jint slot,
2099
            jfloat value) {
2100
    return functions->SetLocalFloat(this, thread, depth, slot, value);
2101
  }
2102

2103
  jvmtiError SetLocalDouble(jthread thread,
2104
            jint depth,
2105
            jint slot,
2106
            jdouble value) {
2107
    return functions->SetLocalDouble(this, thread, depth, slot, value);
2108
  }
2109

2110
  jvmtiError SetBreakpoint(jmethodID method,
2111
            jlocation location) {
2112
    return functions->SetBreakpoint(this, method, location);
2113
  }
2114

2115
  jvmtiError ClearBreakpoint(jmethodID method,
2116
            jlocation location) {
2117
    return functions->ClearBreakpoint(this, method, location);
2118
  }
2119

2120
  jvmtiError SetFieldAccessWatch(jclass klass,
2121
            jfieldID field) {
2122
    return functions->SetFieldAccessWatch(this, klass, field);
2123
  }
2124

2125
  jvmtiError ClearFieldAccessWatch(jclass klass,
2126
            jfieldID field) {
2127
    return functions->ClearFieldAccessWatch(this, klass, field);
2128
  }
2129

2130
  jvmtiError SetFieldModificationWatch(jclass klass,
2131
            jfieldID field) {
2132
    return functions->SetFieldModificationWatch(this, klass, field);
2133
  }
2134

2135
  jvmtiError ClearFieldModificationWatch(jclass klass,
2136
            jfieldID field) {
2137
    return functions->ClearFieldModificationWatch(this, klass, field);
2138
  }
2139

2140
  jvmtiError GetLoadedClasses(jint* class_count_ptr,
2141
            jclass** classes_ptr) {
2142
    return functions->GetLoadedClasses(this, class_count_ptr, classes_ptr);
2143
  }
2144

2145
  jvmtiError GetClassLoaderClasses(jobject initiating_loader,
2146
            jint* class_count_ptr,
2147
            jclass** classes_ptr) {
2148
    return functions->GetClassLoaderClasses(this, initiating_loader, class_count_ptr, classes_ptr);
2149
  }
2150

2151
  jvmtiError GetClassSignature(jclass klass,
2152
            char** signature_ptr,
2153
            char** generic_ptr) {
2154
    return functions->GetClassSignature(this, klass, signature_ptr, generic_ptr);
2155
  }
2156

2157
  jvmtiError GetClassStatus(jclass klass,
2158
            jint* status_ptr) {
2159
    return functions->GetClassStatus(this, klass, status_ptr);
2160
  }
2161

2162
  jvmtiError GetSourceFileName(jclass klass,
2163
            char** source_name_ptr) {
2164
    return functions->GetSourceFileName(this, klass, source_name_ptr);
2165
  }
2166

2167
  jvmtiError GetClassModifiers(jclass klass,
2168
            jint* modifiers_ptr) {
2169
    return functions->GetClassModifiers(this, klass, modifiers_ptr);
2170
  }
2171

2172
  jvmtiError GetClassMethods(jclass klass,
2173
            jint* method_count_ptr,
2174
            jmethodID** methods_ptr) {
2175
    return functions->GetClassMethods(this, klass, method_count_ptr, methods_ptr);
2176
  }
2177

2178
  jvmtiError GetClassFields(jclass klass,
2179
            jint* field_count_ptr,
2180
            jfieldID** fields_ptr) {
2181
    return functions->GetClassFields(this, klass, field_count_ptr, fields_ptr);
2182
  }
2183

2184
  jvmtiError GetImplementedInterfaces(jclass klass,
2185
            jint* interface_count_ptr,
2186
            jclass** interfaces_ptr) {
2187
    return functions->GetImplementedInterfaces(this, klass, interface_count_ptr, interfaces_ptr);
2188
  }
2189

2190
  jvmtiError GetClassVersionNumbers(jclass klass,
2191
            jint* minor_version_ptr,
2192
            jint* major_version_ptr) {
2193
    return functions->GetClassVersionNumbers(this, klass, minor_version_ptr, major_version_ptr);
2194
  }
2195

2196
  jvmtiError GetConstantPool(jclass klass,
2197
            jint* constant_pool_count_ptr,
2198
            jint* constant_pool_byte_count_ptr,
2199
            unsigned char** constant_pool_bytes_ptr) {
2200
    return functions->GetConstantPool(this, klass, constant_pool_count_ptr, constant_pool_byte_count_ptr, constant_pool_bytes_ptr);
2201
  }
2202

2203
  jvmtiError IsInterface(jclass klass,
2204
            jboolean* is_interface_ptr) {
2205
    return functions->IsInterface(this, klass, is_interface_ptr);
2206
  }
2207

2208
  jvmtiError IsArrayClass(jclass klass,
2209
            jboolean* is_array_class_ptr) {
2210
    return functions->IsArrayClass(this, klass, is_array_class_ptr);
2211
  }
2212

2213
  jvmtiError IsModifiableClass(jclass klass,
2214
            jboolean* is_modifiable_class_ptr) {
2215
    return functions->IsModifiableClass(this, klass, is_modifiable_class_ptr);
2216
  }
2217

2218
  jvmtiError GetClassLoader(jclass klass,
2219
            jobject* classloader_ptr) {
2220
    return functions->GetClassLoader(this, klass, classloader_ptr);
2221
  }
2222

2223
  jvmtiError GetSourceDebugExtension(jclass klass,
2224
            char** source_debug_extension_ptr) {
2225
    return functions->GetSourceDebugExtension(this, klass, source_debug_extension_ptr);
2226
  }
2227

2228
  jvmtiError RetransformClasses(jint class_count,
2229
            const jclass* classes) {
2230
    return functions->RetransformClasses(this, class_count, classes);
2231
  }
2232

2233
  jvmtiError RedefineClasses(jint class_count,
2234
            const jvmtiClassDefinition* class_definitions) {
2235
    return functions->RedefineClasses(this, class_count, class_definitions);
2236
  }
2237

2238
  jvmtiError GetObjectSize(jobject object,
2239
            jlong* size_ptr) {
2240
    return functions->GetObjectSize(this, object, size_ptr);
2241
  }
2242

2243
  jvmtiError GetObjectHashCode(jobject object,
2244
            jint* hash_code_ptr) {
2245
    return functions->GetObjectHashCode(this, object, hash_code_ptr);
2246
  }
2247

2248
  jvmtiError GetObjectMonitorUsage(jobject object,
2249
            jvmtiMonitorUsage* info_ptr) {
2250
    return functions->GetObjectMonitorUsage(this, object, info_ptr);
2251
  }
2252

2253
  jvmtiError GetFieldName(jclass klass,
2254
            jfieldID field,
2255
            char** name_ptr,
2256
            char** signature_ptr,
2257
            char** generic_ptr) {
2258
    return functions->GetFieldName(this, klass, field, name_ptr, signature_ptr, generic_ptr);
2259
  }
2260

2261
  jvmtiError GetFieldDeclaringClass(jclass klass,
2262
            jfieldID field,
2263
            jclass* declaring_class_ptr) {
2264
    return functions->GetFieldDeclaringClass(this, klass, field, declaring_class_ptr);
2265
  }
2266

2267
  jvmtiError GetFieldModifiers(jclass klass,
2268
            jfieldID field,
2269
            jint* modifiers_ptr) {
2270
    return functions->GetFieldModifiers(this, klass, field, modifiers_ptr);
2271
  }
2272

2273
  jvmtiError IsFieldSynthetic(jclass klass,
2274
            jfieldID field,
2275
            jboolean* is_synthetic_ptr) {
2276
    return functions->IsFieldSynthetic(this, klass, field, is_synthetic_ptr);
2277
  }
2278

2279
  jvmtiError GetMethodName(jmethodID method,
2280
            char** name_ptr,
2281
            char** signature_ptr,
2282
            char** generic_ptr) {
2283
    return functions->GetMethodName(this, method, name_ptr, signature_ptr, generic_ptr);
2284
  }
2285

2286
  jvmtiError GetMethodDeclaringClass(jmethodID method,
2287
            jclass* declaring_class_ptr) {
2288
    return functions->GetMethodDeclaringClass(this, method, declaring_class_ptr);
2289
  }
2290

2291
  jvmtiError GetMethodModifiers(jmethodID method,
2292
            jint* modifiers_ptr) {
2293
    return functions->GetMethodModifiers(this, method, modifiers_ptr);
2294
  }
2295

2296
  jvmtiError GetMaxLocals(jmethodID method,
2297
            jint* max_ptr) {
2298
    return functions->GetMaxLocals(this, method, max_ptr);
2299
  }
2300

2301
  jvmtiError GetArgumentsSize(jmethodID method,
2302
            jint* size_ptr) {
2303
    return functions->GetArgumentsSize(this, method, size_ptr);
2304
  }
2305

2306
  jvmtiError GetLineNumberTable(jmethodID method,
2307
            jint* entry_count_ptr,
2308
            jvmtiLineNumberEntry** table_ptr) {
2309
    return functions->GetLineNumberTable(this, method, entry_count_ptr, table_ptr);
2310
  }
2311

2312
  jvmtiError GetMethodLocation(jmethodID method,
2313
            jlocation* start_location_ptr,
2314
            jlocation* end_location_ptr) {
2315
    return functions->GetMethodLocation(this, method, start_location_ptr, end_location_ptr);
2316
  }
2317

2318
  jvmtiError GetLocalVariableTable(jmethodID method,
2319
            jint* entry_count_ptr,
2320
            jvmtiLocalVariableEntry** table_ptr) {
2321
    return functions->GetLocalVariableTable(this, method, entry_count_ptr, table_ptr);
2322
  }
2323

2324
  jvmtiError GetBytecodes(jmethodID method,
2325
            jint* bytecode_count_ptr,
2326
            unsigned char** bytecodes_ptr) {
2327
    return functions->GetBytecodes(this, method, bytecode_count_ptr, bytecodes_ptr);
2328
  }
2329

2330
  jvmtiError IsMethodNative(jmethodID method,
2331
            jboolean* is_native_ptr) {
2332
    return functions->IsMethodNative(this, method, is_native_ptr);
2333
  }
2334

2335
  jvmtiError IsMethodSynthetic(jmethodID method,
2336
            jboolean* is_synthetic_ptr) {
2337
    return functions->IsMethodSynthetic(this, method, is_synthetic_ptr);
2338
  }
2339

2340
  jvmtiError IsMethodObsolete(jmethodID method,
2341
            jboolean* is_obsolete_ptr) {
2342
    return functions->IsMethodObsolete(this, method, is_obsolete_ptr);
2343
  }
2344

2345
  jvmtiError SetNativeMethodPrefix(const char* prefix) {
2346
    return functions->SetNativeMethodPrefix(this, prefix);
2347
  }
2348

2349
  jvmtiError SetNativeMethodPrefixes(jint prefix_count,
2350
            char** prefixes) {
2351
    return functions->SetNativeMethodPrefixes(this, prefix_count, prefixes);
2352
  }
2353

2354
  jvmtiError CreateRawMonitor(const char* name,
2355
            jrawMonitorID* monitor_ptr) {
2356
    return functions->CreateRawMonitor(this, name, monitor_ptr);
2357
  }
2358

2359
  jvmtiError DestroyRawMonitor(jrawMonitorID monitor) {
2360
    return functions->DestroyRawMonitor(this, monitor);
2361
  }
2362

2363
  jvmtiError RawMonitorEnter(jrawMonitorID monitor) {
2364
    return functions->RawMonitorEnter(this, monitor);
2365
  }
2366

2367
  jvmtiError RawMonitorExit(jrawMonitorID monitor) {
2368
    return functions->RawMonitorExit(this, monitor);
2369
  }
2370

2371
  jvmtiError RawMonitorWait(jrawMonitorID monitor,
2372
            jlong millis) {
2373
    return functions->RawMonitorWait(this, monitor, millis);
2374
  }
2375

2376
  jvmtiError RawMonitorNotify(jrawMonitorID monitor) {
2377
    return functions->RawMonitorNotify(this, monitor);
2378
  }
2379

2380
  jvmtiError RawMonitorNotifyAll(jrawMonitorID monitor) {
2381
    return functions->RawMonitorNotifyAll(this, monitor);
2382
  }
2383

2384
  jvmtiError SetJNIFunctionTable(const jniNativeInterface* function_table) {
2385
    return functions->SetJNIFunctionTable(this, function_table);
2386
  }
2387

2388
  jvmtiError GetJNIFunctionTable(jniNativeInterface** function_table) {
2389
    return functions->GetJNIFunctionTable(this, function_table);
2390
  }
2391

2392
  jvmtiError SetEventCallbacks(const jvmtiEventCallbacks* callbacks,
2393
            jint size_of_callbacks) {
2394
    return functions->SetEventCallbacks(this, callbacks, size_of_callbacks);
2395
  }
2396

2397
  jvmtiError SetEventNotificationMode(jvmtiEventMode mode,
2398
            jvmtiEvent event_type,
2399
            jthread event_thread,
2400
             ...) {
2401
    return functions->SetEventNotificationMode(this, mode, event_type, event_thread);
2402
  }
2403

2404
  jvmtiError GenerateEvents(jvmtiEvent event_type) {
2405
    return functions->GenerateEvents(this, event_type);
2406
  }
2407

2408
  jvmtiError GetExtensionFunctions(jint* extension_count_ptr,
2409
            jvmtiExtensionFunctionInfo** extensions) {
2410
    return functions->GetExtensionFunctions(this, extension_count_ptr, extensions);
2411
  }
2412

2413
  jvmtiError GetExtensionEvents(jint* extension_count_ptr,
2414
            jvmtiExtensionEventInfo** extensions) {
2415
    return functions->GetExtensionEvents(this, extension_count_ptr, extensions);
2416
  }
2417

2418
  jvmtiError SetExtensionEventCallback(jint extension_event_index,
2419
            jvmtiExtensionEvent callback) {
2420
    return functions->SetExtensionEventCallback(this, extension_event_index, callback);
2421
  }
2422

2423
  jvmtiError GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) {
2424
    return functions->GetPotentialCapabilities(this, capabilities_ptr);
2425
  }
2426

2427
  jvmtiError AddCapabilities(const jvmtiCapabilities* capabilities_ptr) {
2428
    return functions->AddCapabilities(this, capabilities_ptr);
2429
  }
2430

2431
  jvmtiError RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) {
2432
    return functions->RelinquishCapabilities(this, capabilities_ptr);
2433
  }
2434

2435
  jvmtiError GetCapabilities(jvmtiCapabilities* capabilities_ptr) {
2436
    return functions->GetCapabilities(this, capabilities_ptr);
2437
  }
2438

2439
  jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) {
2440
    return functions->GetCurrentThreadCpuTimerInfo(this, info_ptr);
2441
  }
2442

2443
  jvmtiError GetCurrentThreadCpuTime(jlong* nanos_ptr) {
2444
    return functions->GetCurrentThreadCpuTime(this, nanos_ptr);
2445
  }
2446

2447
  jvmtiError GetThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) {
2448
    return functions->GetThreadCpuTimerInfo(this, info_ptr);
2449
  }
2450

2451
  jvmtiError GetThreadCpuTime(jthread thread,
2452
            jlong* nanos_ptr) {
2453
    return functions->GetThreadCpuTime(this, thread, nanos_ptr);
2454
  }
2455

2456
  jvmtiError GetTimerInfo(jvmtiTimerInfo* info_ptr) {
2457
    return functions->GetTimerInfo(this, info_ptr);
2458
  }
2459

2460
  jvmtiError GetTime(jlong* nanos_ptr) {
2461
    return functions->GetTime(this, nanos_ptr);
2462
  }
2463

2464
  jvmtiError GetAvailableProcessors(jint* processor_count_ptr) {
2465
    return functions->GetAvailableProcessors(this, processor_count_ptr);
2466
  }
2467

2468
  jvmtiError AddToBootstrapClassLoaderSearch(const char* segment) {
2469
    return functions->AddToBootstrapClassLoaderSearch(this, segment);
2470
  }
2471

2472
  jvmtiError AddToSystemClassLoaderSearch(const char* segment) {
2473
    return functions->AddToSystemClassLoaderSearch(this, segment);
2474
  }
2475

2476
  jvmtiError GetSystemProperties(jint* count_ptr,
2477
            char*** property_ptr) {
2478
    return functions->GetSystemProperties(this, count_ptr, property_ptr);
2479
  }
2480

2481
  jvmtiError GetSystemProperty(const char* property,
2482
            char** value_ptr) {
2483
    return functions->GetSystemProperty(this, property, value_ptr);
2484
  }
2485

2486
  jvmtiError SetSystemProperty(const char* property,
2487
            const char* value) {
2488
    return functions->SetSystemProperty(this, property, value);
2489
  }
2490

2491
  jvmtiError GetPhase(jvmtiPhase* phase_ptr) {
2492
    return functions->GetPhase(this, phase_ptr);
2493
  }
2494

2495
  jvmtiError DisposeEnvironment() {
2496
    return functions->DisposeEnvironment(this);
2497
  }
2498

2499
  jvmtiError SetEnvironmentLocalStorage(const void* data) {
2500
    return functions->SetEnvironmentLocalStorage(this, data);
2501
  }
2502

2503
  jvmtiError GetEnvironmentLocalStorage(void** data_ptr) {
2504
    return functions->GetEnvironmentLocalStorage(this, data_ptr);
2505
  }
2506

2507
  jvmtiError GetVersionNumber(jint* version_ptr) {
2508
    return functions->GetVersionNumber(this, version_ptr);
2509
  }
2510

2511
  jvmtiError GetErrorName(jvmtiError error,
2512
            char** name_ptr) {
2513
    return functions->GetErrorName(this, error, name_ptr);
2514
  }
2515

2516
  jvmtiError SetVerboseFlag(jvmtiVerboseFlag flag,
2517
            jboolean value) {
2518
    return functions->SetVerboseFlag(this, flag, value);
2519
  }
2520

2521
  jvmtiError GetJLocationFormat(jvmtiJlocationFormat* format_ptr) {
2522
    return functions->GetJLocationFormat(this, format_ptr);
2523
  }
2524

2525
#endif /* __cplusplus */
2526
};
2527

2528

2529
#ifdef __cplusplus
2530
} /* extern "C" */
2531
#endif /* __cplusplus */
2532

2533
#endif /* !_JAVA_JVMTI_H_ */
2534

2535

2536
Product

Resources

Company
