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