jvm_rs/
jvmti.rs

1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4#![allow(dead_code)]
5
6use crate::bitfield::__BindgenBitfieldUnit;
7use crate::jni::*;
8
9pub const JVMTI_VERSION_1: ::std::os::raw::c_uint = 805371904;
10pub const JVMTI_VERSION_1_0: ::std::os::raw::c_uint = 805371904;
11pub const JVMTI_VERSION_1_1: ::std::os::raw::c_uint = 805372160;
12pub const JVMTI_VERSION_1_2: ::std::os::raw::c_uint = 805372416;
13pub const JVMTI_VERSION_9: ::std::os::raw::c_uint = 805896192;
14pub const JVMTI_VERSION_11: ::std::os::raw::c_uint = 806027264;
15pub const JVMTI_VERSION: ::std::os::raw::c_uint = 806289408;
16extern "C" {
17    pub fn Agent_OnLoad(
18        vm: *mut JavaVM,
19        options: *mut ::std::os::raw::c_char,
20        reserved: *mut ::std::os::raw::c_void,
21    ) -> jint;
22}
23extern "C" {
24    pub fn Agent_OnAttach(
25        vm: *mut JavaVM,
26        options: *mut ::std::os::raw::c_char,
27        reserved: *mut ::std::os::raw::c_void,
28    ) -> jint;
29}
30extern "C" {
31    pub fn Agent_OnUnload(vm: *mut JavaVM);
32}
33pub type jvmtiEnv = *const jvmtiInterface_1_;
34pub type jthread = jobject;
35pub type jthreadGroup = jobject;
36pub type jlocation = jlong;
37#[repr(C)]
38#[derive(Debug, Copy, Clone)]
39pub struct _jrawMonitorID {
40    _unused: [u8; 0],
41}
42pub type jrawMonitorID = *mut _jrawMonitorID;
43pub type jniNativeInterface = JNINativeInterface_;
44pub const JVMTI_THREAD_STATE_ALIVE: ::std::os::raw::c_uint = 1;
45pub const JVMTI_THREAD_STATE_TERMINATED: ::std::os::raw::c_uint = 2;
46pub const JVMTI_THREAD_STATE_RUNNABLE: ::std::os::raw::c_uint = 4;
47pub const JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER: ::std::os::raw::c_uint = 1024;
48pub const JVMTI_THREAD_STATE_WAITING: ::std::os::raw::c_uint = 128;
49pub const JVMTI_THREAD_STATE_WAITING_INDEFINITELY: ::std::os::raw::c_uint = 16;
50pub const JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT: ::std::os::raw::c_uint = 32;
51pub const JVMTI_THREAD_STATE_SLEEPING: ::std::os::raw::c_uint = 64;
52pub const JVMTI_THREAD_STATE_IN_OBJECT_WAIT: ::std::os::raw::c_uint = 256;
53pub const JVMTI_THREAD_STATE_PARKED: ::std::os::raw::c_uint = 512;
54pub const JVMTI_THREAD_STATE_SUSPENDED: ::std::os::raw::c_uint = 1048576;
55pub const JVMTI_THREAD_STATE_INTERRUPTED: ::std::os::raw::c_uint = 2097152;
56pub const JVMTI_THREAD_STATE_IN_NATIVE: ::std::os::raw::c_uint = 4194304;
57pub const JVMTI_THREAD_STATE_VENDOR_1: ::std::os::raw::c_uint = 268435456;
58pub const JVMTI_THREAD_STATE_VENDOR_2: ::std::os::raw::c_uint = 536870912;
59pub const JVMTI_THREAD_STATE_VENDOR_3: ::std::os::raw::c_uint = 1073741824;
60pub const JVMTI_JAVA_LANG_THREAD_STATE_MASK: ::std::os::raw::c_uint = 1207;
61pub const JVMTI_JAVA_LANG_THREAD_STATE_NEW: ::std::os::raw::c_uint = 0;
62pub const JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED: ::std::os::raw::c_uint = 2;
63pub const JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE: ::std::os::raw::c_uint = 5;
64pub const JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED: ::std::os::raw::c_uint = 1025;
65pub const JVMTI_JAVA_LANG_THREAD_STATE_WAITING: ::std::os::raw::c_uint = 145;
66pub const JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING: ::std::os::raw::c_uint = 161;
67pub const JVMTI_THREAD_MIN_PRIORITY: ::std::os::raw::c_uint = 1;
68pub const JVMTI_THREAD_NORM_PRIORITY: ::std::os::raw::c_uint = 5;
69pub const JVMTI_THREAD_MAX_PRIORITY: ::std::os::raw::c_uint = 10;
70pub const JVMTI_HEAP_FILTER_TAGGED: ::std::os::raw::c_uint = 4;
71pub const JVMTI_HEAP_FILTER_UNTAGGED: ::std::os::raw::c_uint = 8;
72pub const JVMTI_HEAP_FILTER_CLASS_TAGGED: ::std::os::raw::c_uint = 16;
73pub const JVMTI_HEAP_FILTER_CLASS_UNTAGGED: ::std::os::raw::c_uint = 32;
74pub const JVMTI_VISIT_OBJECTS: ::std::os::raw::c_uint = 256;
75pub const JVMTI_VISIT_ABORT: ::std::os::raw::c_uint = 32768;
76pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_CLASS: jvmtiHeapReferenceKind = 1;
77pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_FIELD: jvmtiHeapReferenceKind = 2;
78pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT: jvmtiHeapReferenceKind = 3;
79pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_CLASS_LOADER: jvmtiHeapReferenceKind = 4;
80pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_SIGNERS: jvmtiHeapReferenceKind = 5;
81pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN: jvmtiHeapReferenceKind = 6;
82pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_INTERFACE: jvmtiHeapReferenceKind = 7;
83pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_STATIC_FIELD: jvmtiHeapReferenceKind = 8;
84pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_CONSTANT_POOL: jvmtiHeapReferenceKind = 9;
85pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_SUPERCLASS: jvmtiHeapReferenceKind = 10;
86pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_JNI_GLOBAL: jvmtiHeapReferenceKind = 21;
87pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_SYSTEM_CLASS: jvmtiHeapReferenceKind = 22;
88pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_MONITOR: jvmtiHeapReferenceKind = 23;
89pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_STACK_LOCAL: jvmtiHeapReferenceKind = 24;
90pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_JNI_LOCAL: jvmtiHeapReferenceKind = 25;
91pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_THREAD: jvmtiHeapReferenceKind = 26;
92pub const jvmtiHeapReferenceKind_JVMTI_HEAP_REFERENCE_OTHER: jvmtiHeapReferenceKind = 27;
93pub type jvmtiHeapReferenceKind = ::std::os::raw::c_uint;
94pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_BOOLEAN: jvmtiPrimitiveType = 90;
95pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_BYTE: jvmtiPrimitiveType = 66;
96pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_CHAR: jvmtiPrimitiveType = 67;
97pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_SHORT: jvmtiPrimitiveType = 83;
98pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_INT: jvmtiPrimitiveType = 73;
99pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_LONG: jvmtiPrimitiveType = 74;
100pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_FLOAT: jvmtiPrimitiveType = 70;
101pub const jvmtiPrimitiveType_JVMTI_PRIMITIVE_TYPE_DOUBLE: jvmtiPrimitiveType = 68;
102pub type jvmtiPrimitiveType = ::std::os::raw::c_uint;
103pub const jvmtiHeapObjectFilter_JVMTI_HEAP_OBJECT_TAGGED: jvmtiHeapObjectFilter = 1;
104pub const jvmtiHeapObjectFilter_JVMTI_HEAP_OBJECT_UNTAGGED: jvmtiHeapObjectFilter = 2;
105pub const jvmtiHeapObjectFilter_JVMTI_HEAP_OBJECT_EITHER: jvmtiHeapObjectFilter = 3;
106pub type jvmtiHeapObjectFilter = ::std::os::raw::c_uint;
107pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_JNI_GLOBAL: jvmtiHeapRootKind = 1;
108pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_SYSTEM_CLASS: jvmtiHeapRootKind = 2;
109pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_MONITOR: jvmtiHeapRootKind = 3;
110pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_STACK_LOCAL: jvmtiHeapRootKind = 4;
111pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_JNI_LOCAL: jvmtiHeapRootKind = 5;
112pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_THREAD: jvmtiHeapRootKind = 6;
113pub const jvmtiHeapRootKind_JVMTI_HEAP_ROOT_OTHER: jvmtiHeapRootKind = 7;
114pub type jvmtiHeapRootKind = ::std::os::raw::c_uint;
115pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_CLASS: jvmtiObjectReferenceKind = 1;
116pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_FIELD: jvmtiObjectReferenceKind = 2;
117pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_ARRAY_ELEMENT: jvmtiObjectReferenceKind = 3;
118pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_CLASS_LOADER: jvmtiObjectReferenceKind = 4;
119pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_SIGNERS: jvmtiObjectReferenceKind = 5;
120pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_PROTECTION_DOMAIN: jvmtiObjectReferenceKind = 6;
121pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_INTERFACE: jvmtiObjectReferenceKind = 7;
122pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_STATIC_FIELD: jvmtiObjectReferenceKind = 8;
123pub const jvmtiObjectReferenceKind_JVMTI_REFERENCE_CONSTANT_POOL: jvmtiObjectReferenceKind = 9;
124pub type jvmtiObjectReferenceKind = ::std::os::raw::c_uint;
125pub const jvmtiIterationControl_JVMTI_ITERATION_CONTINUE: jvmtiIterationControl = 1;
126pub const jvmtiIterationControl_JVMTI_ITERATION_IGNORE: jvmtiIterationControl = 2;
127pub const jvmtiIterationControl_JVMTI_ITERATION_ABORT: jvmtiIterationControl = 0;
128pub type jvmtiIterationControl = ::std::os::raw::c_uint;
129pub const JVMTI_CLASS_STATUS_VERIFIED: ::std::os::raw::c_uint = 1;
130pub const JVMTI_CLASS_STATUS_PREPARED: ::std::os::raw::c_uint = 2;
131pub const JVMTI_CLASS_STATUS_INITIALIZED: ::std::os::raw::c_uint = 4;
132pub const JVMTI_CLASS_STATUS_ERROR: ::std::os::raw::c_uint = 8;
133pub const JVMTI_CLASS_STATUS_ARRAY: ::std::os::raw::c_uint = 16;
134pub const JVMTI_CLASS_STATUS_PRIMITIVE: ::std::os::raw::c_uint = 32;
135pub const jvmtiEventMode_JVMTI_ENABLE: jvmtiEventMode = 1;
136pub const jvmtiEventMode_JVMTI_DISABLE: jvmtiEventMode = 0;
137pub type jvmtiEventMode = ::std::os::raw::c_uint;
138pub const jvmtiParamTypes_JVMTI_TYPE_JBYTE: jvmtiParamTypes = 101;
139pub const jvmtiParamTypes_JVMTI_TYPE_JCHAR: jvmtiParamTypes = 102;
140pub const jvmtiParamTypes_JVMTI_TYPE_JSHORT: jvmtiParamTypes = 103;
141pub const jvmtiParamTypes_JVMTI_TYPE_JINT: jvmtiParamTypes = 104;
142pub const jvmtiParamTypes_JVMTI_TYPE_JLONG: jvmtiParamTypes = 105;
143pub const jvmtiParamTypes_JVMTI_TYPE_JFLOAT: jvmtiParamTypes = 106;
144pub const jvmtiParamTypes_JVMTI_TYPE_JDOUBLE: jvmtiParamTypes = 107;
145pub const jvmtiParamTypes_JVMTI_TYPE_JBOOLEAN: jvmtiParamTypes = 108;
146pub const jvmtiParamTypes_JVMTI_TYPE_JOBJECT: jvmtiParamTypes = 109;
147pub const jvmtiParamTypes_JVMTI_TYPE_JTHREAD: jvmtiParamTypes = 110;
148pub const jvmtiParamTypes_JVMTI_TYPE_JCLASS: jvmtiParamTypes = 111;
149pub const jvmtiParamTypes_JVMTI_TYPE_JVALUE: jvmtiParamTypes = 112;
150pub const jvmtiParamTypes_JVMTI_TYPE_JFIELDID: jvmtiParamTypes = 113;
151pub const jvmtiParamTypes_JVMTI_TYPE_JMETHODID: jvmtiParamTypes = 114;
152pub const jvmtiParamTypes_JVMTI_TYPE_CCHAR: jvmtiParamTypes = 115;
153pub const jvmtiParamTypes_JVMTI_TYPE_CVOID: jvmtiParamTypes = 116;
154pub const jvmtiParamTypes_JVMTI_TYPE_JNIENV: jvmtiParamTypes = 117;
155pub type jvmtiParamTypes = ::std::os::raw::c_uint;
156pub const jvmtiParamKind_JVMTI_KIND_IN: jvmtiParamKind = 91;
157pub const jvmtiParamKind_JVMTI_KIND_IN_PTR: jvmtiParamKind = 92;
158pub const jvmtiParamKind_JVMTI_KIND_IN_BUF: jvmtiParamKind = 93;
159pub const jvmtiParamKind_JVMTI_KIND_ALLOC_BUF: jvmtiParamKind = 94;
160pub const jvmtiParamKind_JVMTI_KIND_ALLOC_ALLOC_BUF: jvmtiParamKind = 95;
161pub const jvmtiParamKind_JVMTI_KIND_OUT: jvmtiParamKind = 96;
162pub const jvmtiParamKind_JVMTI_KIND_OUT_BUF: jvmtiParamKind = 97;
163pub type jvmtiParamKind = ::std::os::raw::c_uint;
164pub const jvmtiTimerKind_JVMTI_TIMER_USER_CPU: jvmtiTimerKind = 30;
165pub const jvmtiTimerKind_JVMTI_TIMER_TOTAL_CPU: jvmtiTimerKind = 31;
166pub const jvmtiTimerKind_JVMTI_TIMER_ELAPSED: jvmtiTimerKind = 32;
167pub type jvmtiTimerKind = ::std::os::raw::c_uint;
168pub const jvmtiPhase_JVMTI_PHASE_ONLOAD: jvmtiPhase = 1;
169pub const jvmtiPhase_JVMTI_PHASE_PRIMORDIAL: jvmtiPhase = 2;
170pub const jvmtiPhase_JVMTI_PHASE_START: jvmtiPhase = 6;
171pub const jvmtiPhase_JVMTI_PHASE_LIVE: jvmtiPhase = 4;
172pub const jvmtiPhase_JVMTI_PHASE_DEAD: jvmtiPhase = 8;
173pub type jvmtiPhase = ::std::os::raw::c_uint;
174pub const JVMTI_VERSION_INTERFACE_JNI: ::std::os::raw::c_uint = 0;
175pub const JVMTI_VERSION_INTERFACE_JVMTI: ::std::os::raw::c_uint = 805306368;
176pub const JVMTI_VERSION_MASK_INTERFACE_TYPE: ::std::os::raw::c_uint = 1879048192;
177pub const JVMTI_VERSION_MASK_MAJOR: ::std::os::raw::c_uint = 268369920;
178pub const JVMTI_VERSION_MASK_MINOR: ::std::os::raw::c_uint = 65280;
179pub const JVMTI_VERSION_MASK_MICRO: ::std::os::raw::c_uint = 255;
180pub const JVMTI_VERSION_SHIFT_MAJOR: ::std::os::raw::c_uint = 16;
181pub const JVMTI_VERSION_SHIFT_MINOR: ::std::os::raw::c_uint = 8;
182pub const JVMTI_VERSION_SHIFT_MICRO: ::std::os::raw::c_uint = 0;
183pub const jvmtiVerboseFlag_JVMTI_VERBOSE_OTHER: jvmtiVerboseFlag = 0;
184pub const jvmtiVerboseFlag_JVMTI_VERBOSE_GC: jvmtiVerboseFlag = 1;
185pub const jvmtiVerboseFlag_JVMTI_VERBOSE_CLASS: jvmtiVerboseFlag = 2;
186pub const jvmtiVerboseFlag_JVMTI_VERBOSE_JNI: jvmtiVerboseFlag = 4;
187pub type jvmtiVerboseFlag = ::std::os::raw::c_uint;
188pub const jvmtiJlocationFormat_JVMTI_JLOCATION_JVMBCI: jvmtiJlocationFormat = 1;
189pub const jvmtiJlocationFormat_JVMTI_JLOCATION_MACHINEPC: jvmtiJlocationFormat = 2;
190pub const jvmtiJlocationFormat_JVMTI_JLOCATION_OTHER: jvmtiJlocationFormat = 0;
191pub type jvmtiJlocationFormat = ::std::os::raw::c_uint;
192pub const JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR: ::std::os::raw::c_uint = 1;
193pub const JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP: ::std::os::raw::c_uint = 2;
194pub const JVMTI_RESOURCE_EXHAUSTED_THREADS: ::std::os::raw::c_uint = 4;
195pub const jvmtiError_JVMTI_ERROR_NONE: jvmtiError = 0;
196pub const jvmtiError_JVMTI_ERROR_INVALID_THREAD: jvmtiError = 10;
197pub const jvmtiError_JVMTI_ERROR_INVALID_THREAD_GROUP: jvmtiError = 11;
198pub const jvmtiError_JVMTI_ERROR_INVALID_PRIORITY: jvmtiError = 12;
199pub const jvmtiError_JVMTI_ERROR_THREAD_NOT_SUSPENDED: jvmtiError = 13;
200pub const jvmtiError_JVMTI_ERROR_THREAD_SUSPENDED: jvmtiError = 14;
201pub const jvmtiError_JVMTI_ERROR_THREAD_NOT_ALIVE: jvmtiError = 15;
202pub const jvmtiError_JVMTI_ERROR_INVALID_OBJECT: jvmtiError = 20;
203pub const jvmtiError_JVMTI_ERROR_INVALID_CLASS: jvmtiError = 21;
204pub const jvmtiError_JVMTI_ERROR_CLASS_NOT_PREPARED: jvmtiError = 22;
205pub const jvmtiError_JVMTI_ERROR_INVALID_METHODID: jvmtiError = 23;
206pub const jvmtiError_JVMTI_ERROR_INVALID_LOCATION: jvmtiError = 24;
207pub const jvmtiError_JVMTI_ERROR_INVALID_FIELDID: jvmtiError = 25;
208pub const jvmtiError_JVMTI_ERROR_INVALID_MODULE: jvmtiError = 26;
209pub const jvmtiError_JVMTI_ERROR_NO_MORE_FRAMES: jvmtiError = 31;
210pub const jvmtiError_JVMTI_ERROR_OPAQUE_FRAME: jvmtiError = 32;
211pub const jvmtiError_JVMTI_ERROR_TYPE_MISMATCH: jvmtiError = 34;
212pub const jvmtiError_JVMTI_ERROR_INVALID_SLOT: jvmtiError = 35;
213pub const jvmtiError_JVMTI_ERROR_DUPLICATE: jvmtiError = 40;
214pub const jvmtiError_JVMTI_ERROR_NOT_FOUND: jvmtiError = 41;
215pub const jvmtiError_JVMTI_ERROR_INVALID_MONITOR: jvmtiError = 50;
216pub const jvmtiError_JVMTI_ERROR_NOT_MONITOR_OWNER: jvmtiError = 51;
217pub const jvmtiError_JVMTI_ERROR_INTERRUPT: jvmtiError = 52;
218pub const jvmtiError_JVMTI_ERROR_INVALID_CLASS_FORMAT: jvmtiError = 60;
219pub const jvmtiError_JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION: jvmtiError = 61;
220pub const jvmtiError_JVMTI_ERROR_FAILS_VERIFICATION: jvmtiError = 62;
221pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED: jvmtiError = 63;
222pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED: jvmtiError = 64;
223pub const jvmtiError_JVMTI_ERROR_INVALID_TYPESTATE: jvmtiError = 65;
224pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED: jvmtiError = 66;
225pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED: jvmtiError = 67;
226pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_VERSION: jvmtiError = 68;
227pub const jvmtiError_JVMTI_ERROR_NAMES_DONT_MATCH: jvmtiError = 69;
228pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED: jvmtiError = 70;
229pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED: jvmtiError = 71;
230pub const jvmtiError_JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED: jvmtiError = 72;
231pub const jvmtiError_JVMTI_ERROR_UNMODIFIABLE_CLASS: jvmtiError = 79;
232pub const jvmtiError_JVMTI_ERROR_UNMODIFIABLE_MODULE: jvmtiError = 80;
233pub const jvmtiError_JVMTI_ERROR_NOT_AVAILABLE: jvmtiError = 98;
234pub const jvmtiError_JVMTI_ERROR_MUST_POSSESS_CAPABILITY: jvmtiError = 99;
235pub const jvmtiError_JVMTI_ERROR_NULL_POINTER: jvmtiError = 100;
236pub const jvmtiError_JVMTI_ERROR_ABSENT_INFORMATION: jvmtiError = 101;
237pub const jvmtiError_JVMTI_ERROR_INVALID_EVENT_TYPE: jvmtiError = 102;
238pub const jvmtiError_JVMTI_ERROR_ILLEGAL_ARGUMENT: jvmtiError = 103;
239pub const jvmtiError_JVMTI_ERROR_NATIVE_METHOD: jvmtiError = 104;
240pub const jvmtiError_JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED: jvmtiError = 106;
241pub const jvmtiError_JVMTI_ERROR_OUT_OF_MEMORY: jvmtiError = 110;
242pub const jvmtiError_JVMTI_ERROR_ACCESS_DENIED: jvmtiError = 111;
243pub const jvmtiError_JVMTI_ERROR_WRONG_PHASE: jvmtiError = 112;
244pub const jvmtiError_JVMTI_ERROR_INTERNAL: jvmtiError = 113;
245pub const jvmtiError_JVMTI_ERROR_UNATTACHED_THREAD: jvmtiError = 115;
246pub const jvmtiError_JVMTI_ERROR_INVALID_ENVIRONMENT: jvmtiError = 116;
247pub const jvmtiError_JVMTI_ERROR_MAX: jvmtiError = 116;
248pub type jvmtiError = ::std::os::raw::c_uint;
249pub const jvmtiEvent_JVMTI_MIN_EVENT_TYPE_VAL: jvmtiEvent = 50;
250pub const jvmtiEvent_JVMTI_EVENT_VM_INIT: jvmtiEvent = 50;
251pub const jvmtiEvent_JVMTI_EVENT_VM_DEATH: jvmtiEvent = 51;
252pub const jvmtiEvent_JVMTI_EVENT_THREAD_START: jvmtiEvent = 52;
253pub const jvmtiEvent_JVMTI_EVENT_THREAD_END: jvmtiEvent = 53;
254pub const jvmtiEvent_JVMTI_EVENT_CLASS_FILE_LOAD_HOOK: jvmtiEvent = 54;
255pub const jvmtiEvent_JVMTI_EVENT_CLASS_LOAD: jvmtiEvent = 55;
256pub const jvmtiEvent_JVMTI_EVENT_CLASS_PREPARE: jvmtiEvent = 56;
257pub const jvmtiEvent_JVMTI_EVENT_VM_START: jvmtiEvent = 57;
258pub const jvmtiEvent_JVMTI_EVENT_EXCEPTION: jvmtiEvent = 58;
259pub const jvmtiEvent_JVMTI_EVENT_EXCEPTION_CATCH: jvmtiEvent = 59;
260pub const jvmtiEvent_JVMTI_EVENT_SINGLE_STEP: jvmtiEvent = 60;
261pub const jvmtiEvent_JVMTI_EVENT_FRAME_POP: jvmtiEvent = 61;
262pub const jvmtiEvent_JVMTI_EVENT_BREAKPOINT: jvmtiEvent = 62;
263pub const jvmtiEvent_JVMTI_EVENT_FIELD_ACCESS: jvmtiEvent = 63;
264pub const jvmtiEvent_JVMTI_EVENT_FIELD_MODIFICATION: jvmtiEvent = 64;
265pub const jvmtiEvent_JVMTI_EVENT_METHOD_ENTRY: jvmtiEvent = 65;
266pub const jvmtiEvent_JVMTI_EVENT_METHOD_EXIT: jvmtiEvent = 66;
267pub const jvmtiEvent_JVMTI_EVENT_NATIVE_METHOD_BIND: jvmtiEvent = 67;
268pub const jvmtiEvent_JVMTI_EVENT_COMPILED_METHOD_LOAD: jvmtiEvent = 68;
269pub const jvmtiEvent_JVMTI_EVENT_COMPILED_METHOD_UNLOAD: jvmtiEvent = 69;
270pub const jvmtiEvent_JVMTI_EVENT_DYNAMIC_CODE_GENERATED: jvmtiEvent = 70;
271pub const jvmtiEvent_JVMTI_EVENT_DATA_DUMP_REQUEST: jvmtiEvent = 71;
272pub const jvmtiEvent_JVMTI_EVENT_MONITOR_WAIT: jvmtiEvent = 73;
273pub const jvmtiEvent_JVMTI_EVENT_MONITOR_WAITED: jvmtiEvent = 74;
274pub const jvmtiEvent_JVMTI_EVENT_MONITOR_CONTENDED_ENTER: jvmtiEvent = 75;
275pub const jvmtiEvent_JVMTI_EVENT_MONITOR_CONTENDED_ENTERED: jvmtiEvent = 76;
276pub const jvmtiEvent_JVMTI_EVENT_RESOURCE_EXHAUSTED: jvmtiEvent = 80;
277pub const jvmtiEvent_JVMTI_EVENT_GARBAGE_COLLECTION_START: jvmtiEvent = 81;
278pub const jvmtiEvent_JVMTI_EVENT_GARBAGE_COLLECTION_FINISH: jvmtiEvent = 82;
279pub const jvmtiEvent_JVMTI_EVENT_OBJECT_FREE: jvmtiEvent = 83;
280pub const jvmtiEvent_JVMTI_EVENT_VM_OBJECT_ALLOC: jvmtiEvent = 84;
281pub const jvmtiEvent_JVMTI_EVENT_SAMPLED_OBJECT_ALLOC: jvmtiEvent = 86;
282pub const jvmtiEvent_JVMTI_MAX_EVENT_TYPE_VAL: jvmtiEvent = 86;
283pub type jvmtiEvent = ::std::os::raw::c_uint;
284pub type jvmtiThreadInfo = _jvmtiThreadInfo;
285pub type jvmtiMonitorStackDepthInfo = _jvmtiMonitorStackDepthInfo;
286pub type jvmtiThreadGroupInfo = _jvmtiThreadGroupInfo;
287pub type jvmtiFrameInfo = _jvmtiFrameInfo;
288pub type jvmtiStackInfo = _jvmtiStackInfo;
289pub type jvmtiHeapReferenceInfoField = _jvmtiHeapReferenceInfoField;
290pub type jvmtiHeapReferenceInfoArray = _jvmtiHeapReferenceInfoArray;
291pub type jvmtiHeapReferenceInfoConstantPool = _jvmtiHeapReferenceInfoConstantPool;
292pub type jvmtiHeapReferenceInfoStackLocal = _jvmtiHeapReferenceInfoStackLocal;
293pub type jvmtiHeapReferenceInfoJniLocal = _jvmtiHeapReferenceInfoJniLocal;
294pub type jvmtiHeapReferenceInfoReserved = _jvmtiHeapReferenceInfoReserved;
295pub type jvmtiHeapReferenceInfo = _jvmtiHeapReferenceInfo;
296pub type jvmtiHeapCallbacks = _jvmtiHeapCallbacks;
297pub type jvmtiClassDefinition = _jvmtiClassDefinition;
298pub type jvmtiMonitorUsage = _jvmtiMonitorUsage;
299pub type jvmtiLineNumberEntry = _jvmtiLineNumberEntry;
300pub type jvmtiLocalVariableEntry = _jvmtiLocalVariableEntry;
301pub type jvmtiParamInfo = _jvmtiParamInfo;
302pub type jvmtiExtensionFunctionInfo = _jvmtiExtensionFunctionInfo;
303pub type jvmtiExtensionEventInfo = _jvmtiExtensionEventInfo;
304pub type jvmtiTimerInfo = _jvmtiTimerInfo;
305pub type jvmtiAddrLocationMap = _jvmtiAddrLocationMap;
306pub type jvmtiStartFunction = ::std::option::Option<
307    unsafe extern "C" fn(
308        jvmti_env: *mut jvmtiEnv,
309        jni_env: *mut JNIEnv,
310        arg: *mut ::std::os::raw::c_void,
311    ),
312>;
313pub type jvmtiHeapIterationCallback = ::std::option::Option<
314    unsafe extern "C" fn(
315        class_tag: jlong,
316        size: jlong,
317        tag_ptr: *mut jlong,
318        length: jint,
319        user_data: *mut ::std::os::raw::c_void,
320    ) -> jint,
321>;
322pub type jvmtiHeapReferenceCallback = ::std::option::Option<
323    unsafe extern "C" fn(
324        reference_kind: jvmtiHeapReferenceKind,
325        reference_info: *const jvmtiHeapReferenceInfo,
326        class_tag: jlong,
327        referrer_class_tag: jlong,
328        size: jlong,
329        tag_ptr: *mut jlong,
330        referrer_tag_ptr: *mut jlong,
331        length: jint,
332        user_data: *mut ::std::os::raw::c_void,
333    ) -> jint,
334>;
335pub type jvmtiPrimitiveFieldCallback = ::std::option::Option<
336    unsafe extern "C" fn(
337        kind: jvmtiHeapReferenceKind,
338        info: *const jvmtiHeapReferenceInfo,
339        object_class_tag: jlong,
340        object_tag_ptr: *mut jlong,
341        value: jvalue,
342        value_type: jvmtiPrimitiveType,
343        user_data: *mut ::std::os::raw::c_void,
344    ) -> jint,
345>;
346pub type jvmtiArrayPrimitiveValueCallback = ::std::option::Option<
347    unsafe extern "C" fn(
348        class_tag: jlong,
349        size: jlong,
350        tag_ptr: *mut jlong,
351        element_count: jint,
352        element_type: jvmtiPrimitiveType,
353        elements: *const ::std::os::raw::c_void,
354        user_data: *mut ::std::os::raw::c_void,
355    ) -> jint,
356>;
357pub type jvmtiStringPrimitiveValueCallback = ::std::option::Option<
358    unsafe extern "C" fn(
359        class_tag: jlong,
360        size: jlong,
361        tag_ptr: *mut jlong,
362        value: *const jchar,
363        value_length: jint,
364        user_data: *mut ::std::os::raw::c_void,
365    ) -> jint,
366>;
367pub type jvmtiReservedCallback = ::std::option::Option<unsafe extern "C" fn() -> jint>;
368pub type jvmtiHeapObjectCallback = ::std::option::Option<
369    unsafe extern "C" fn(
370        class_tag: jlong,
371        size: jlong,
372        tag_ptr: *mut jlong,
373        user_data: *mut ::std::os::raw::c_void,
374    ) -> jvmtiIterationControl,
375>;
376pub type jvmtiHeapRootCallback = ::std::option::Option<
377    unsafe extern "C" fn(
378        root_kind: jvmtiHeapRootKind,
379        class_tag: jlong,
380        size: jlong,
381        tag_ptr: *mut jlong,
382        user_data: *mut ::std::os::raw::c_void,
383    ) -> jvmtiIterationControl,
384>;
385pub type jvmtiStackReferenceCallback = ::std::option::Option<
386    unsafe extern "C" fn(
387        root_kind: jvmtiHeapRootKind,
388        class_tag: jlong,
389        size: jlong,
390        tag_ptr: *mut jlong,
391        thread_tag: jlong,
392        depth: jint,
393        method: jmethodID,
394        slot: jint,
395        user_data: *mut ::std::os::raw::c_void,
396    ) -> jvmtiIterationControl,
397>;
398pub type jvmtiObjectReferenceCallback = ::std::option::Option<
399    unsafe extern "C" fn(
400        reference_kind: jvmtiObjectReferenceKind,
401        class_tag: jlong,
402        size: jlong,
403        tag_ptr: *mut jlong,
404        referrer_tag: jlong,
405        referrer_index: jint,
406        user_data: *mut ::std::os::raw::c_void,
407    ) -> jvmtiIterationControl,
408>;
409pub type jvmtiExtensionFunction =
410    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, ...) -> jvmtiError>;
411pub type jvmtiExtensionEvent =
412    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, ...)>;
413#[repr(C)]
414#[derive(Debug, Copy, Clone)]
415pub struct _jvmtiThreadInfo {
416    pub name: *mut ::std::os::raw::c_char,
417    pub priority: jint,
418    pub is_daemon: jboolean,
419    pub thread_group: jthreadGroup,
420    pub context_class_loader: jobject,
421}
422#[repr(C)]
423#[derive(Debug, Copy, Clone)]
424pub struct _jvmtiMonitorStackDepthInfo {
425    pub monitor: jobject,
426    pub stack_depth: jint,
427}
428#[repr(C)]
429#[derive(Debug, Copy, Clone)]
430pub struct _jvmtiThreadGroupInfo {
431    pub parent: jthreadGroup,
432    pub name: *mut ::std::os::raw::c_char,
433    pub max_priority: jint,
434    pub is_daemon: jboolean,
435}
436#[repr(C)]
437#[derive(Debug, Copy, Clone)]
438pub struct _jvmtiFrameInfo {
439    pub method: jmethodID,
440    pub location: jlocation,
441}
442#[repr(C)]
443#[derive(Debug, Copy, Clone)]
444pub struct _jvmtiStackInfo {
445    pub thread: jthread,
446    pub state: jint,
447    pub frame_buffer: *mut jvmtiFrameInfo,
448    pub frame_count: jint,
449}
450#[repr(C)]
451#[derive(Debug, Copy, Clone)]
452pub struct _jvmtiHeapReferenceInfoField {
453    pub index: jint,
454}
455#[repr(C)]
456#[derive(Debug, Copy, Clone)]
457pub struct _jvmtiHeapReferenceInfoArray {
458    pub index: jint,
459}
460#[repr(C)]
461#[derive(Debug, Copy, Clone)]
462pub struct _jvmtiHeapReferenceInfoConstantPool {
463    pub index: jint,
464}
465#[repr(C)]
466#[derive(Debug, Copy, Clone)]
467pub struct _jvmtiHeapReferenceInfoStackLocal {
468    pub thread_tag: jlong,
469    pub thread_id: jlong,
470    pub depth: jint,
471    pub method: jmethodID,
472    pub location: jlocation,
473    pub slot: jint,
474}
475#[repr(C)]
476#[derive(Debug, Copy, Clone)]
477pub struct _jvmtiHeapReferenceInfoJniLocal {
478    pub thread_tag: jlong,
479    pub thread_id: jlong,
480    pub depth: jint,
481    pub method: jmethodID,
482}
483#[repr(C)]
484#[derive(Debug, Copy, Clone)]
485pub struct _jvmtiHeapReferenceInfoReserved {
486    pub reserved1: jlong,
487    pub reserved2: jlong,
488    pub reserved3: jlong,
489    pub reserved4: jlong,
490    pub reserved5: jlong,
491    pub reserved6: jlong,
492    pub reserved7: jlong,
493    pub reserved8: jlong,
494}
495#[repr(C)]
496#[derive(Copy, Clone)]
497pub union _jvmtiHeapReferenceInfo {
498    pub field: jvmtiHeapReferenceInfoField,
499    pub array: jvmtiHeapReferenceInfoArray,
500    pub constant_pool: jvmtiHeapReferenceInfoConstantPool,
501    pub stack_local: jvmtiHeapReferenceInfoStackLocal,
502    pub jni_local: jvmtiHeapReferenceInfoJniLocal,
503    pub other: jvmtiHeapReferenceInfoReserved,
504    _bindgen_union_align: [u64; 8usize],
505}
506#[repr(C)]
507#[derive(Debug, Copy, Clone)]
508pub struct _jvmtiHeapCallbacks {
509    pub heap_iteration_callback: jvmtiHeapIterationCallback,
510    pub heap_reference_callback: jvmtiHeapReferenceCallback,
511    pub primitive_field_callback: jvmtiPrimitiveFieldCallback,
512    pub array_primitive_value_callback: jvmtiArrayPrimitiveValueCallback,
513    pub string_primitive_value_callback: jvmtiStringPrimitiveValueCallback,
514    pub reserved5: jvmtiReservedCallback,
515    pub reserved6: jvmtiReservedCallback,
516    pub reserved7: jvmtiReservedCallback,
517    pub reserved8: jvmtiReservedCallback,
518    pub reserved9: jvmtiReservedCallback,
519    pub reserved10: jvmtiReservedCallback,
520    pub reserved11: jvmtiReservedCallback,
521    pub reserved12: jvmtiReservedCallback,
522    pub reserved13: jvmtiReservedCallback,
523    pub reserved14: jvmtiReservedCallback,
524    pub reserved15: jvmtiReservedCallback,
525}
526#[repr(C)]
527#[derive(Debug, Copy, Clone)]
528pub struct _jvmtiClassDefinition {
529    pub klass: jclass,
530    pub class_byte_count: jint,
531    pub class_bytes: *const ::std::os::raw::c_uchar,
532}
533#[repr(C)]
534#[derive(Debug, Copy, Clone)]
535pub struct _jvmtiMonitorUsage {
536    pub owner: jthread,
537    pub entry_count: jint,
538    pub waiter_count: jint,
539    pub waiters: *mut jthread,
540    pub notify_waiter_count: jint,
541    pub notify_waiters: *mut jthread,
542}
543#[repr(C)]
544#[derive(Debug, Copy, Clone)]
545pub struct _jvmtiLineNumberEntry {
546    pub start_location: jlocation,
547    pub line_number: jint,
548}
549#[repr(C)]
550#[derive(Debug, Copy, Clone)]
551pub struct _jvmtiLocalVariableEntry {
552    pub start_location: jlocation,
553    pub length: jint,
554    pub name: *mut ::std::os::raw::c_char,
555    pub signature: *mut ::std::os::raw::c_char,
556    pub generic_signature: *mut ::std::os::raw::c_char,
557    pub slot: jint,
558}
559#[repr(C)]
560#[derive(Debug, Copy, Clone)]
561pub struct _jvmtiParamInfo {
562    pub name: *mut ::std::os::raw::c_char,
563    pub kind: jvmtiParamKind,
564    pub base_type: jvmtiParamTypes,
565    pub null_ok: jboolean,
566}
567#[repr(C)]
568#[derive(Debug, Copy, Clone)]
569pub struct _jvmtiExtensionFunctionInfo {
570    pub func: jvmtiExtensionFunction,
571    pub id: *mut ::std::os::raw::c_char,
572    pub short_description: *mut ::std::os::raw::c_char,
573    pub param_count: jint,
574    pub params: *mut jvmtiParamInfo,
575    pub error_count: jint,
576    pub errors: *mut jvmtiError,
577}
578#[repr(C)]
579#[derive(Debug, Copy, Clone)]
580pub struct _jvmtiExtensionEventInfo {
581    pub extension_event_index: jint,
582    pub id: *mut ::std::os::raw::c_char,
583    pub short_description: *mut ::std::os::raw::c_char,
584    pub param_count: jint,
585    pub params: *mut jvmtiParamInfo,
586}
587#[repr(C)]
588#[derive(Debug, Copy, Clone)]
589pub struct _jvmtiTimerInfo {
590    pub max_value: jlong,
591    pub may_skip_forward: jboolean,
592    pub may_skip_backward: jboolean,
593    pub kind: jvmtiTimerKind,
594    pub reserved1: jlong,
595    pub reserved2: jlong,
596}
597#[repr(C)]
598#[derive(Debug, Copy, Clone)]
599pub struct _jvmtiAddrLocationMap {
600    pub start_address: *const ::std::os::raw::c_void,
601    pub location: jlocation,
602}
603#[repr(C)]
604#[repr(align(4))]
605#[derive(Debug, Copy, Clone)]
606pub struct jvmtiCapabilities {
607    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u8>,
608}
609impl jvmtiCapabilities {
610    #[inline]
611    pub fn can_tag_objects(&self) -> ::std::os::raw::c_uint {
612        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
613    }
614    #[inline]
615    pub fn set_can_tag_objects(&mut self, val: ::std::os::raw::c_uint) {
616        unsafe {
617            let val: u32 = ::std::mem::transmute(val);
618            self._bitfield_1.set(0usize, 1u8, val as u64)
619        }
620    }
621    #[inline]
622    pub fn can_generate_field_modification_events(&self) -> ::std::os::raw::c_uint {
623        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
624    }
625    #[inline]
626    pub fn set_can_generate_field_modification_events(&mut self, val: ::std::os::raw::c_uint) {
627        unsafe {
628            let val: u32 = ::std::mem::transmute(val);
629            self._bitfield_1.set(1usize, 1u8, val as u64)
630        }
631    }
632    #[inline]
633    pub fn can_generate_field_access_events(&self) -> ::std::os::raw::c_uint {
634        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
635    }
636    #[inline]
637    pub fn set_can_generate_field_access_events(&mut self, val: ::std::os::raw::c_uint) {
638        unsafe {
639            let val: u32 = ::std::mem::transmute(val);
640            self._bitfield_1.set(2usize, 1u8, val as u64)
641        }
642    }
643    #[inline]
644    pub fn can_get_bytecodes(&self) -> ::std::os::raw::c_uint {
645        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
646    }
647    #[inline]
648    pub fn set_can_get_bytecodes(&mut self, val: ::std::os::raw::c_uint) {
649        unsafe {
650            let val: u32 = ::std::mem::transmute(val);
651            self._bitfield_1.set(3usize, 1u8, val as u64)
652        }
653    }
654    #[inline]
655    pub fn can_get_synthetic_attribute(&self) -> ::std::os::raw::c_uint {
656        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
657    }
658    #[inline]
659    pub fn set_can_get_synthetic_attribute(&mut self, val: ::std::os::raw::c_uint) {
660        unsafe {
661            let val: u32 = ::std::mem::transmute(val);
662            self._bitfield_1.set(4usize, 1u8, val as u64)
663        }
664    }
665    #[inline]
666    pub fn can_get_owned_monitor_info(&self) -> ::std::os::raw::c_uint {
667        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
668    }
669    #[inline]
670    pub fn set_can_get_owned_monitor_info(&mut self, val: ::std::os::raw::c_uint) {
671        unsafe {
672            let val: u32 = ::std::mem::transmute(val);
673            self._bitfield_1.set(5usize, 1u8, val as u64)
674        }
675    }
676    #[inline]
677    pub fn can_get_current_contended_monitor(&self) -> ::std::os::raw::c_uint {
678        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
679    }
680    #[inline]
681    pub fn set_can_get_current_contended_monitor(&mut self, val: ::std::os::raw::c_uint) {
682        unsafe {
683            let val: u32 = ::std::mem::transmute(val);
684            self._bitfield_1.set(6usize, 1u8, val as u64)
685        }
686    }
687    #[inline]
688    pub fn can_get_monitor_info(&self) -> ::std::os::raw::c_uint {
689        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
690    }
691    #[inline]
692    pub fn set_can_get_monitor_info(&mut self, val: ::std::os::raw::c_uint) {
693        unsafe {
694            let val: u32 = ::std::mem::transmute(val);
695            self._bitfield_1.set(7usize, 1u8, val as u64)
696        }
697    }
698    #[inline]
699    pub fn can_pop_frame(&self) -> ::std::os::raw::c_uint {
700        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
701    }
702    #[inline]
703    pub fn set_can_pop_frame(&mut self, val: ::std::os::raw::c_uint) {
704        unsafe {
705            let val: u32 = ::std::mem::transmute(val);
706            self._bitfield_1.set(8usize, 1u8, val as u64)
707        }
708    }
709    #[inline]
710    pub fn can_redefine_classes(&self) -> ::std::os::raw::c_uint {
711        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
712    }
713    #[inline]
714    pub fn set_can_redefine_classes(&mut self, val: ::std::os::raw::c_uint) {
715        unsafe {
716            let val: u32 = ::std::mem::transmute(val);
717            self._bitfield_1.set(9usize, 1u8, val as u64)
718        }
719    }
720    #[inline]
721    pub fn can_signal_thread(&self) -> ::std::os::raw::c_uint {
722        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
723    }
724    #[inline]
725    pub fn set_can_signal_thread(&mut self, val: ::std::os::raw::c_uint) {
726        unsafe {
727            let val: u32 = ::std::mem::transmute(val);
728            self._bitfield_1.set(10usize, 1u8, val as u64)
729        }
730    }
731    #[inline]
732    pub fn can_get_source_file_name(&self) -> ::std::os::raw::c_uint {
733        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
734    }
735    #[inline]
736    pub fn set_can_get_source_file_name(&mut self, val: ::std::os::raw::c_uint) {
737        unsafe {
738            let val: u32 = ::std::mem::transmute(val);
739            self._bitfield_1.set(11usize, 1u8, val as u64)
740        }
741    }
742    #[inline]
743    pub fn can_get_line_numbers(&self) -> ::std::os::raw::c_uint {
744        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
745    }
746    #[inline]
747    pub fn set_can_get_line_numbers(&mut self, val: ::std::os::raw::c_uint) {
748        unsafe {
749            let val: u32 = ::std::mem::transmute(val);
750            self._bitfield_1.set(12usize, 1u8, val as u64)
751        }
752    }
753    #[inline]
754    pub fn can_get_source_debug_extension(&self) -> ::std::os::raw::c_uint {
755        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
756    }
757    #[inline]
758    pub fn set_can_get_source_debug_extension(&mut self, val: ::std::os::raw::c_uint) {
759        unsafe {
760            let val: u32 = ::std::mem::transmute(val);
761            self._bitfield_1.set(13usize, 1u8, val as u64)
762        }
763    }
764    #[inline]
765    pub fn can_access_local_variables(&self) -> ::std::os::raw::c_uint {
766        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
767    }
768    #[inline]
769    pub fn set_can_access_local_variables(&mut self, val: ::std::os::raw::c_uint) {
770        unsafe {
771            let val: u32 = ::std::mem::transmute(val);
772            self._bitfield_1.set(14usize, 1u8, val as u64)
773        }
774    }
775    #[inline]
776    pub fn can_maintain_original_method_order(&self) -> ::std::os::raw::c_uint {
777        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
778    }
779    #[inline]
780    pub fn set_can_maintain_original_method_order(&mut self, val: ::std::os::raw::c_uint) {
781        unsafe {
782            let val: u32 = ::std::mem::transmute(val);
783            self._bitfield_1.set(15usize, 1u8, val as u64)
784        }
785    }
786    #[inline]
787    pub fn can_generate_single_step_events(&self) -> ::std::os::raw::c_uint {
788        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
789    }
790    #[inline]
791    pub fn set_can_generate_single_step_events(&mut self, val: ::std::os::raw::c_uint) {
792        unsafe {
793            let val: u32 = ::std::mem::transmute(val);
794            self._bitfield_1.set(16usize, 1u8, val as u64)
795        }
796    }
797    #[inline]
798    pub fn can_generate_exception_events(&self) -> ::std::os::raw::c_uint {
799        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
800    }
801    #[inline]
802    pub fn set_can_generate_exception_events(&mut self, val: ::std::os::raw::c_uint) {
803        unsafe {
804            let val: u32 = ::std::mem::transmute(val);
805            self._bitfield_1.set(17usize, 1u8, val as u64)
806        }
807    }
808    #[inline]
809    pub fn can_generate_frame_pop_events(&self) -> ::std::os::raw::c_uint {
810        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
811    }
812    #[inline]
813    pub fn set_can_generate_frame_pop_events(&mut self, val: ::std::os::raw::c_uint) {
814        unsafe {
815            let val: u32 = ::std::mem::transmute(val);
816            self._bitfield_1.set(18usize, 1u8, val as u64)
817        }
818    }
819    #[inline]
820    pub fn can_generate_breakpoint_events(&self) -> ::std::os::raw::c_uint {
821        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
822    }
823    #[inline]
824    pub fn set_can_generate_breakpoint_events(&mut self, val: ::std::os::raw::c_uint) {
825        unsafe {
826            let val: u32 = ::std::mem::transmute(val);
827            self._bitfield_1.set(19usize, 1u8, val as u64)
828        }
829    }
830    #[inline]
831    pub fn can_suspend(&self) -> ::std::os::raw::c_uint {
832        unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
833    }
834    #[inline]
835    pub fn set_can_suspend(&mut self, val: ::std::os::raw::c_uint) {
836        unsafe {
837            let val: u32 = ::std::mem::transmute(val);
838            self._bitfield_1.set(20usize, 1u8, val as u64)
839        }
840    }
841    #[inline]
842    pub fn can_redefine_any_class(&self) -> ::std::os::raw::c_uint {
843        unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
844    }
845    #[inline]
846    pub fn set_can_redefine_any_class(&mut self, val: ::std::os::raw::c_uint) {
847        unsafe {
848            let val: u32 = ::std::mem::transmute(val);
849            self._bitfield_1.set(21usize, 1u8, val as u64)
850        }
851    }
852    #[inline]
853    pub fn can_get_current_thread_cpu_time(&self) -> ::std::os::raw::c_uint {
854        unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
855    }
856    #[inline]
857    pub fn set_can_get_current_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) {
858        unsafe {
859            let val: u32 = ::std::mem::transmute(val);
860            self._bitfield_1.set(22usize, 1u8, val as u64)
861        }
862    }
863    #[inline]
864    pub fn can_get_thread_cpu_time(&self) -> ::std::os::raw::c_uint {
865        unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
866    }
867    #[inline]
868    pub fn set_can_get_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) {
869        unsafe {
870            let val: u32 = ::std::mem::transmute(val);
871            self._bitfield_1.set(23usize, 1u8, val as u64)
872        }
873    }
874    #[inline]
875    pub fn can_generate_method_entry_events(&self) -> ::std::os::raw::c_uint {
876        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
877    }
878    #[inline]
879    pub fn set_can_generate_method_entry_events(&mut self, val: ::std::os::raw::c_uint) {
880        unsafe {
881            let val: u32 = ::std::mem::transmute(val);
882            self._bitfield_1.set(24usize, 1u8, val as u64)
883        }
884    }
885    #[inline]
886    pub fn can_generate_method_exit_events(&self) -> ::std::os::raw::c_uint {
887        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
888    }
889    #[inline]
890    pub fn set_can_generate_method_exit_events(&mut self, val: ::std::os::raw::c_uint) {
891        unsafe {
892            let val: u32 = ::std::mem::transmute(val);
893            self._bitfield_1.set(25usize, 1u8, val as u64)
894        }
895    }
896    #[inline]
897    pub fn can_generate_all_class_hook_events(&self) -> ::std::os::raw::c_uint {
898        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
899    }
900    #[inline]
901    pub fn set_can_generate_all_class_hook_events(&mut self, val: ::std::os::raw::c_uint) {
902        unsafe {
903            let val: u32 = ::std::mem::transmute(val);
904            self._bitfield_1.set(26usize, 1u8, val as u64)
905        }
906    }
907    #[inline]
908    pub fn can_generate_compiled_method_load_events(&self) -> ::std::os::raw::c_uint {
909        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
910    }
911    #[inline]
912    pub fn set_can_generate_compiled_method_load_events(&mut self, val: ::std::os::raw::c_uint) {
913        unsafe {
914            let val: u32 = ::std::mem::transmute(val);
915            self._bitfield_1.set(27usize, 1u8, val as u64)
916        }
917    }
918    #[inline]
919    pub fn can_generate_monitor_events(&self) -> ::std::os::raw::c_uint {
920        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
921    }
922    #[inline]
923    pub fn set_can_generate_monitor_events(&mut self, val: ::std::os::raw::c_uint) {
924        unsafe {
925            let val: u32 = ::std::mem::transmute(val);
926            self._bitfield_1.set(28usize, 1u8, val as u64)
927        }
928    }
929    #[inline]
930    pub fn can_generate_vm_object_alloc_events(&self) -> ::std::os::raw::c_uint {
931        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
932    }
933    #[inline]
934    pub fn set_can_generate_vm_object_alloc_events(&mut self, val: ::std::os::raw::c_uint) {
935        unsafe {
936            let val: u32 = ::std::mem::transmute(val);
937            self._bitfield_1.set(29usize, 1u8, val as u64)
938        }
939    }
940    #[inline]
941    pub fn can_generate_native_method_bind_events(&self) -> ::std::os::raw::c_uint {
942        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
943    }
944    #[inline]
945    pub fn set_can_generate_native_method_bind_events(&mut self, val: ::std::os::raw::c_uint) {
946        unsafe {
947            let val: u32 = ::std::mem::transmute(val);
948            self._bitfield_1.set(30usize, 1u8, val as u64)
949        }
950    }
951    #[inline]
952    pub fn can_generate_garbage_collection_events(&self) -> ::std::os::raw::c_uint {
953        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
954    }
955    #[inline]
956    pub fn set_can_generate_garbage_collection_events(&mut self, val: ::std::os::raw::c_uint) {
957        unsafe {
958            let val: u32 = ::std::mem::transmute(val);
959            self._bitfield_1.set(31usize, 1u8, val as u64)
960        }
961    }
962    #[inline]
963    pub fn can_generate_object_free_events(&self) -> ::std::os::raw::c_uint {
964        unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) }
965    }
966    #[inline]
967    pub fn set_can_generate_object_free_events(&mut self, val: ::std::os::raw::c_uint) {
968        unsafe {
969            let val: u32 = ::std::mem::transmute(val);
970            self._bitfield_1.set(32usize, 1u8, val as u64)
971        }
972    }
973    #[inline]
974    pub fn can_force_early_return(&self) -> ::std::os::raw::c_uint {
975        unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) }
976    }
977    #[inline]
978    pub fn set_can_force_early_return(&mut self, val: ::std::os::raw::c_uint) {
979        unsafe {
980            let val: u32 = ::std::mem::transmute(val);
981            self._bitfield_1.set(33usize, 1u8, val as u64)
982        }
983    }
984    #[inline]
985    pub fn can_get_owned_monitor_stack_depth_info(&self) -> ::std::os::raw::c_uint {
986        unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) }
987    }
988    #[inline]
989    pub fn set_can_get_owned_monitor_stack_depth_info(&mut self, val: ::std::os::raw::c_uint) {
990        unsafe {
991            let val: u32 = ::std::mem::transmute(val);
992            self._bitfield_1.set(34usize, 1u8, val as u64)
993        }
994    }
995    #[inline]
996    pub fn can_get_constant_pool(&self) -> ::std::os::raw::c_uint {
997        unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) }
998    }
999    #[inline]
1000    pub fn set_can_get_constant_pool(&mut self, val: ::std::os::raw::c_uint) {
1001        unsafe {
1002            let val: u32 = ::std::mem::transmute(val);
1003            self._bitfield_1.set(35usize, 1u8, val as u64)
1004        }
1005    }
1006    #[inline]
1007    pub fn can_set_native_method_prefix(&self) -> ::std::os::raw::c_uint {
1008        unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) }
1009    }
1010    #[inline]
1011    pub fn set_can_set_native_method_prefix(&mut self, val: ::std::os::raw::c_uint) {
1012        unsafe {
1013            let val: u32 = ::std::mem::transmute(val);
1014            self._bitfield_1.set(36usize, 1u8, val as u64)
1015        }
1016    }
1017    #[inline]
1018    pub fn can_retransform_classes(&self) -> ::std::os::raw::c_uint {
1019        unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) }
1020    }
1021    #[inline]
1022    pub fn set_can_retransform_classes(&mut self, val: ::std::os::raw::c_uint) {
1023        unsafe {
1024            let val: u32 = ::std::mem::transmute(val);
1025            self._bitfield_1.set(37usize, 1u8, val as u64)
1026        }
1027    }
1028    #[inline]
1029    pub fn can_retransform_any_class(&self) -> ::std::os::raw::c_uint {
1030        unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) }
1031    }
1032    #[inline]
1033    pub fn set_can_retransform_any_class(&mut self, val: ::std::os::raw::c_uint) {
1034        unsafe {
1035            let val: u32 = ::std::mem::transmute(val);
1036            self._bitfield_1.set(38usize, 1u8, val as u64)
1037        }
1038    }
1039    #[inline]
1040    pub fn can_generate_resource_exhaustion_heap_events(&self) -> ::std::os::raw::c_uint {
1041        unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) }
1042    }
1043    #[inline]
1044    pub fn set_can_generate_resource_exhaustion_heap_events(
1045        &mut self,
1046        val: ::std::os::raw::c_uint,
1047    ) {
1048        unsafe {
1049            let val: u32 = ::std::mem::transmute(val);
1050            self._bitfield_1.set(39usize, 1u8, val as u64)
1051        }
1052    }
1053    #[inline]
1054    pub fn can_generate_resource_exhaustion_threads_events(&self) -> ::std::os::raw::c_uint {
1055        unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) }
1056    }
1057    #[inline]
1058    pub fn set_can_generate_resource_exhaustion_threads_events(
1059        &mut self,
1060        val: ::std::os::raw::c_uint,
1061    ) {
1062        unsafe {
1063            let val: u32 = ::std::mem::transmute(val);
1064            self._bitfield_1.set(40usize, 1u8, val as u64)
1065        }
1066    }
1067    #[inline]
1068    pub fn can_generate_early_vmstart(&self) -> ::std::os::raw::c_uint {
1069        unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u32) }
1070    }
1071    #[inline]
1072    pub fn set_can_generate_early_vmstart(&mut self, val: ::std::os::raw::c_uint) {
1073        unsafe {
1074            let val: u32 = ::std::mem::transmute(val);
1075            self._bitfield_1.set(41usize, 1u8, val as u64)
1076        }
1077    }
1078    #[inline]
1079    pub fn can_generate_early_class_hook_events(&self) -> ::std::os::raw::c_uint {
1080        unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u32) }
1081    }
1082    #[inline]
1083    pub fn set_can_generate_early_class_hook_events(&mut self, val: ::std::os::raw::c_uint) {
1084        unsafe {
1085            let val: u32 = ::std::mem::transmute(val);
1086            self._bitfield_1.set(42usize, 1u8, val as u64)
1087        }
1088    }
1089    #[inline]
1090    pub fn can_generate_sampled_object_alloc_events(&self) -> ::std::os::raw::c_uint {
1091        unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u32) }
1092    }
1093    #[inline]
1094    pub fn set_can_generate_sampled_object_alloc_events(&mut self, val: ::std::os::raw::c_uint) {
1095        unsafe {
1096            let val: u32 = ::std::mem::transmute(val);
1097            self._bitfield_1.set(43usize, 1u8, val as u64)
1098        }
1099    }
1100    #[inline]
1101    pub fn new_bitfield_1(
1102        can_tag_objects: ::std::os::raw::c_uint,
1103        can_generate_field_modification_events: ::std::os::raw::c_uint,
1104        can_generate_field_access_events: ::std::os::raw::c_uint,
1105        can_get_bytecodes: ::std::os::raw::c_uint,
1106        can_get_synthetic_attribute: ::std::os::raw::c_uint,
1107        can_get_owned_monitor_info: ::std::os::raw::c_uint,
1108        can_get_current_contended_monitor: ::std::os::raw::c_uint,
1109        can_get_monitor_info: ::std::os::raw::c_uint,
1110        can_pop_frame: ::std::os::raw::c_uint,
1111        can_redefine_classes: ::std::os::raw::c_uint,
1112        can_signal_thread: ::std::os::raw::c_uint,
1113        can_get_source_file_name: ::std::os::raw::c_uint,
1114        can_get_line_numbers: ::std::os::raw::c_uint,
1115        can_get_source_debug_extension: ::std::os::raw::c_uint,
1116        can_access_local_variables: ::std::os::raw::c_uint,
1117        can_maintain_original_method_order: ::std::os::raw::c_uint,
1118        can_generate_single_step_events: ::std::os::raw::c_uint,
1119        can_generate_exception_events: ::std::os::raw::c_uint,
1120        can_generate_frame_pop_events: ::std::os::raw::c_uint,
1121        can_generate_breakpoint_events: ::std::os::raw::c_uint,
1122        can_suspend: ::std::os::raw::c_uint,
1123        can_redefine_any_class: ::std::os::raw::c_uint,
1124        can_get_current_thread_cpu_time: ::std::os::raw::c_uint,
1125        can_get_thread_cpu_time: ::std::os::raw::c_uint,
1126        can_generate_method_entry_events: ::std::os::raw::c_uint,
1127        can_generate_method_exit_events: ::std::os::raw::c_uint,
1128        can_generate_all_class_hook_events: ::std::os::raw::c_uint,
1129        can_generate_compiled_method_load_events: ::std::os::raw::c_uint,
1130        can_generate_monitor_events: ::std::os::raw::c_uint,
1131        can_generate_vm_object_alloc_events: ::std::os::raw::c_uint,
1132        can_generate_native_method_bind_events: ::std::os::raw::c_uint,
1133        can_generate_garbage_collection_events: ::std::os::raw::c_uint,
1134        can_generate_object_free_events: ::std::os::raw::c_uint,
1135        can_force_early_return: ::std::os::raw::c_uint,
1136        can_get_owned_monitor_stack_depth_info: ::std::os::raw::c_uint,
1137        can_get_constant_pool: ::std::os::raw::c_uint,
1138        can_set_native_method_prefix: ::std::os::raw::c_uint,
1139        can_retransform_classes: ::std::os::raw::c_uint,
1140        can_retransform_any_class: ::std::os::raw::c_uint,
1141        can_generate_resource_exhaustion_heap_events: ::std::os::raw::c_uint,
1142        can_generate_resource_exhaustion_threads_events: ::std::os::raw::c_uint,
1143        can_generate_early_vmstart: ::std::os::raw::c_uint,
1144        can_generate_early_class_hook_events: ::std::os::raw::c_uint,
1145        can_generate_sampled_object_alloc_events: ::std::os::raw::c_uint,
1146    ) -> __BindgenBitfieldUnit<[u8; 16usize], u8> {
1147        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize], u8> =
1148            Default::default();
1149        __bindgen_bitfield_unit.set(0usize, 1u8, {
1150            let can_tag_objects: u32 = unsafe { ::std::mem::transmute(can_tag_objects) };
1151            can_tag_objects as u64
1152        });
1153        __bindgen_bitfield_unit.set(1usize, 1u8, {
1154            let can_generate_field_modification_events: u32 =
1155                unsafe { ::std::mem::transmute(can_generate_field_modification_events) };
1156            can_generate_field_modification_events as u64
1157        });
1158        __bindgen_bitfield_unit.set(2usize, 1u8, {
1159            let can_generate_field_access_events: u32 =
1160                unsafe { ::std::mem::transmute(can_generate_field_access_events) };
1161            can_generate_field_access_events as u64
1162        });
1163        __bindgen_bitfield_unit.set(3usize, 1u8, {
1164            let can_get_bytecodes: u32 = unsafe { ::std::mem::transmute(can_get_bytecodes) };
1165            can_get_bytecodes as u64
1166        });
1167        __bindgen_bitfield_unit.set(4usize, 1u8, {
1168            let can_get_synthetic_attribute: u32 =
1169                unsafe { ::std::mem::transmute(can_get_synthetic_attribute) };
1170            can_get_synthetic_attribute as u64
1171        });
1172        __bindgen_bitfield_unit.set(5usize, 1u8, {
1173            let can_get_owned_monitor_info: u32 =
1174                unsafe { ::std::mem::transmute(can_get_owned_monitor_info) };
1175            can_get_owned_monitor_info as u64
1176        });
1177        __bindgen_bitfield_unit.set(6usize, 1u8, {
1178            let can_get_current_contended_monitor: u32 =
1179                unsafe { ::std::mem::transmute(can_get_current_contended_monitor) };
1180            can_get_current_contended_monitor as u64
1181        });
1182        __bindgen_bitfield_unit.set(7usize, 1u8, {
1183            let can_get_monitor_info: u32 = unsafe { ::std::mem::transmute(can_get_monitor_info) };
1184            can_get_monitor_info as u64
1185        });
1186        __bindgen_bitfield_unit.set(8usize, 1u8, {
1187            let can_pop_frame: u32 = unsafe { ::std::mem::transmute(can_pop_frame) };
1188            can_pop_frame as u64
1189        });
1190        __bindgen_bitfield_unit.set(9usize, 1u8, {
1191            let can_redefine_classes: u32 = unsafe { ::std::mem::transmute(can_redefine_classes) };
1192            can_redefine_classes as u64
1193        });
1194        __bindgen_bitfield_unit.set(10usize, 1u8, {
1195            let can_signal_thread: u32 = unsafe { ::std::mem::transmute(can_signal_thread) };
1196            can_signal_thread as u64
1197        });
1198        __bindgen_bitfield_unit.set(11usize, 1u8, {
1199            let can_get_source_file_name: u32 =
1200                unsafe { ::std::mem::transmute(can_get_source_file_name) };
1201            can_get_source_file_name as u64
1202        });
1203        __bindgen_bitfield_unit.set(12usize, 1u8, {
1204            let can_get_line_numbers: u32 = unsafe { ::std::mem::transmute(can_get_line_numbers) };
1205            can_get_line_numbers as u64
1206        });
1207        __bindgen_bitfield_unit.set(13usize, 1u8, {
1208            let can_get_source_debug_extension: u32 =
1209                unsafe { ::std::mem::transmute(can_get_source_debug_extension) };
1210            can_get_source_debug_extension as u64
1211        });
1212        __bindgen_bitfield_unit.set(14usize, 1u8, {
1213            let can_access_local_variables: u32 =
1214                unsafe { ::std::mem::transmute(can_access_local_variables) };
1215            can_access_local_variables as u64
1216        });
1217        __bindgen_bitfield_unit.set(15usize, 1u8, {
1218            let can_maintain_original_method_order: u32 =
1219                unsafe { ::std::mem::transmute(can_maintain_original_method_order) };
1220            can_maintain_original_method_order as u64
1221        });
1222        __bindgen_bitfield_unit.set(16usize, 1u8, {
1223            let can_generate_single_step_events: u32 =
1224                unsafe { ::std::mem::transmute(can_generate_single_step_events) };
1225            can_generate_single_step_events as u64
1226        });
1227        __bindgen_bitfield_unit.set(17usize, 1u8, {
1228            let can_generate_exception_events: u32 =
1229                unsafe { ::std::mem::transmute(can_generate_exception_events) };
1230            can_generate_exception_events as u64
1231        });
1232        __bindgen_bitfield_unit.set(18usize, 1u8, {
1233            let can_generate_frame_pop_events: u32 =
1234                unsafe { ::std::mem::transmute(can_generate_frame_pop_events) };
1235            can_generate_frame_pop_events as u64
1236        });
1237        __bindgen_bitfield_unit.set(19usize, 1u8, {
1238            let can_generate_breakpoint_events: u32 =
1239                unsafe { ::std::mem::transmute(can_generate_breakpoint_events) };
1240            can_generate_breakpoint_events as u64
1241        });
1242        __bindgen_bitfield_unit.set(20usize, 1u8, {
1243            let can_suspend: u32 = unsafe { ::std::mem::transmute(can_suspend) };
1244            can_suspend as u64
1245        });
1246        __bindgen_bitfield_unit.set(21usize, 1u8, {
1247            let can_redefine_any_class: u32 =
1248                unsafe { ::std::mem::transmute(can_redefine_any_class) };
1249            can_redefine_any_class as u64
1250        });
1251        __bindgen_bitfield_unit.set(22usize, 1u8, {
1252            let can_get_current_thread_cpu_time: u32 =
1253                unsafe { ::std::mem::transmute(can_get_current_thread_cpu_time) };
1254            can_get_current_thread_cpu_time as u64
1255        });
1256        __bindgen_bitfield_unit.set(23usize, 1u8, {
1257            let can_get_thread_cpu_time: u32 =
1258                unsafe { ::std::mem::transmute(can_get_thread_cpu_time) };
1259            can_get_thread_cpu_time as u64
1260        });
1261        __bindgen_bitfield_unit.set(24usize, 1u8, {
1262            let can_generate_method_entry_events: u32 =
1263                unsafe { ::std::mem::transmute(can_generate_method_entry_events) };
1264            can_generate_method_entry_events as u64
1265        });
1266        __bindgen_bitfield_unit.set(25usize, 1u8, {
1267            let can_generate_method_exit_events: u32 =
1268                unsafe { ::std::mem::transmute(can_generate_method_exit_events) };
1269            can_generate_method_exit_events as u64
1270        });
1271        __bindgen_bitfield_unit.set(26usize, 1u8, {
1272            let can_generate_all_class_hook_events: u32 =
1273                unsafe { ::std::mem::transmute(can_generate_all_class_hook_events) };
1274            can_generate_all_class_hook_events as u64
1275        });
1276        __bindgen_bitfield_unit.set(27usize, 1u8, {
1277            let can_generate_compiled_method_load_events: u32 =
1278                unsafe { ::std::mem::transmute(can_generate_compiled_method_load_events) };
1279            can_generate_compiled_method_load_events as u64
1280        });
1281        __bindgen_bitfield_unit.set(28usize, 1u8, {
1282            let can_generate_monitor_events: u32 =
1283                unsafe { ::std::mem::transmute(can_generate_monitor_events) };
1284            can_generate_monitor_events as u64
1285        });
1286        __bindgen_bitfield_unit.set(29usize, 1u8, {
1287            let can_generate_vm_object_alloc_events: u32 =
1288                unsafe { ::std::mem::transmute(can_generate_vm_object_alloc_events) };
1289            can_generate_vm_object_alloc_events as u64
1290        });
1291        __bindgen_bitfield_unit.set(30usize, 1u8, {
1292            let can_generate_native_method_bind_events: u32 =
1293                unsafe { ::std::mem::transmute(can_generate_native_method_bind_events) };
1294            can_generate_native_method_bind_events as u64
1295        });
1296        __bindgen_bitfield_unit.set(31usize, 1u8, {
1297            let can_generate_garbage_collection_events: u32 =
1298                unsafe { ::std::mem::transmute(can_generate_garbage_collection_events) };
1299            can_generate_garbage_collection_events as u64
1300        });
1301        __bindgen_bitfield_unit.set(32usize, 1u8, {
1302            let can_generate_object_free_events: u32 =
1303                unsafe { ::std::mem::transmute(can_generate_object_free_events) };
1304            can_generate_object_free_events as u64
1305        });
1306        __bindgen_bitfield_unit.set(33usize, 1u8, {
1307            let can_force_early_return: u32 =
1308                unsafe { ::std::mem::transmute(can_force_early_return) };
1309            can_force_early_return as u64
1310        });
1311        __bindgen_bitfield_unit.set(34usize, 1u8, {
1312            let can_get_owned_monitor_stack_depth_info: u32 =
1313                unsafe { ::std::mem::transmute(can_get_owned_monitor_stack_depth_info) };
1314            can_get_owned_monitor_stack_depth_info as u64
1315        });
1316        __bindgen_bitfield_unit.set(35usize, 1u8, {
1317            let can_get_constant_pool: u32 =
1318                unsafe { ::std::mem::transmute(can_get_constant_pool) };
1319            can_get_constant_pool as u64
1320        });
1321        __bindgen_bitfield_unit.set(36usize, 1u8, {
1322            let can_set_native_method_prefix: u32 =
1323                unsafe { ::std::mem::transmute(can_set_native_method_prefix) };
1324            can_set_native_method_prefix as u64
1325        });
1326        __bindgen_bitfield_unit.set(37usize, 1u8, {
1327            let can_retransform_classes: u32 =
1328                unsafe { ::std::mem::transmute(can_retransform_classes) };
1329            can_retransform_classes as u64
1330        });
1331        __bindgen_bitfield_unit.set(38usize, 1u8, {
1332            let can_retransform_any_class: u32 =
1333                unsafe { ::std::mem::transmute(can_retransform_any_class) };
1334            can_retransform_any_class as u64
1335        });
1336        __bindgen_bitfield_unit.set(39usize, 1u8, {
1337            let can_generate_resource_exhaustion_heap_events: u32 =
1338                unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_heap_events) };
1339            can_generate_resource_exhaustion_heap_events as u64
1340        });
1341        __bindgen_bitfield_unit.set(40usize, 1u8, {
1342            let can_generate_resource_exhaustion_threads_events: u32 =
1343                unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_threads_events) };
1344            can_generate_resource_exhaustion_threads_events as u64
1345        });
1346        __bindgen_bitfield_unit.set(41usize, 1u8, {
1347            let can_generate_early_vmstart: u32 =
1348                unsafe { ::std::mem::transmute(can_generate_early_vmstart) };
1349            can_generate_early_vmstart as u64
1350        });
1351        __bindgen_bitfield_unit.set(42usize, 1u8, {
1352            let can_generate_early_class_hook_events: u32 =
1353                unsafe { ::std::mem::transmute(can_generate_early_class_hook_events) };
1354            can_generate_early_class_hook_events as u64
1355        });
1356        __bindgen_bitfield_unit.set(43usize, 1u8, {
1357            let can_generate_sampled_object_alloc_events: u32 =
1358                unsafe { ::std::mem::transmute(can_generate_sampled_object_alloc_events) };
1359            can_generate_sampled_object_alloc_events as u64
1360        });
1361        __bindgen_bitfield_unit
1362    }
1363}
1364pub type jvmtiEventReserved = ::std::option::Option<unsafe extern "C" fn()>;
1365pub type jvmtiEventBreakpoint = ::std::option::Option<
1366    unsafe extern "C" fn(
1367        jvmti_env: *mut jvmtiEnv,
1368        jni_env: *mut JNIEnv,
1369        thread: jthread,
1370        method: jmethodID,
1371        location: jlocation,
1372    ),
1373>;
1374pub type jvmtiEventClassFileLoadHook = ::std::option::Option<
1375    unsafe extern "C" fn(
1376        jvmti_env: *mut jvmtiEnv,
1377        jni_env: *mut JNIEnv,
1378        class_being_redefined: jclass,
1379        loader: jobject,
1380        name: *const ::std::os::raw::c_char,
1381        protection_domain: jobject,
1382        class_data_len: jint,
1383        class_data: *const ::std::os::raw::c_uchar,
1384        new_class_data_len: *mut jint,
1385        new_class_data: *mut *mut ::std::os::raw::c_uchar,
1386    ),
1387>;
1388pub type jvmtiEventClassLoad = ::std::option::Option<
1389    unsafe extern "C" fn(
1390        jvmti_env: *mut jvmtiEnv,
1391        jni_env: *mut JNIEnv,
1392        thread: jthread,
1393        klass: jclass,
1394    ),
1395>;
1396pub type jvmtiEventClassPrepare = ::std::option::Option<
1397    unsafe extern "C" fn(
1398        jvmti_env: *mut jvmtiEnv,
1399        jni_env: *mut JNIEnv,
1400        thread: jthread,
1401        klass: jclass,
1402    ),
1403>;
1404pub type jvmtiEventCompiledMethodLoad = ::std::option::Option<
1405    unsafe extern "C" fn(
1406        jvmti_env: *mut jvmtiEnv,
1407        method: jmethodID,
1408        code_size: jint,
1409        code_addr: *const ::std::os::raw::c_void,
1410        map_length: jint,
1411        map: *const jvmtiAddrLocationMap,
1412        compile_info: *const ::std::os::raw::c_void,
1413    ),
1414>;
1415pub type jvmtiEventCompiledMethodUnload = ::std::option::Option<
1416    unsafe extern "C" fn(
1417        jvmti_env: *mut jvmtiEnv,
1418        method: jmethodID,
1419        code_addr: *const ::std::os::raw::c_void,
1420    ),
1421>;
1422pub type jvmtiEventDataDumpRequest =
1423    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv)>;
1424pub type jvmtiEventDynamicCodeGenerated = ::std::option::Option<
1425    unsafe extern "C" fn(
1426        jvmti_env: *mut jvmtiEnv,
1427        name: *const ::std::os::raw::c_char,
1428        address: *const ::std::os::raw::c_void,
1429        length: jint,
1430    ),
1431>;
1432pub type jvmtiEventException = ::std::option::Option<
1433    unsafe extern "C" fn(
1434        jvmti_env: *mut jvmtiEnv,
1435        jni_env: *mut JNIEnv,
1436        thread: jthread,
1437        method: jmethodID,
1438        location: jlocation,
1439        exception: jobject,
1440        catch_method: jmethodID,
1441        catch_location: jlocation,
1442    ),
1443>;
1444pub type jvmtiEventExceptionCatch = ::std::option::Option<
1445    unsafe extern "C" fn(
1446        jvmti_env: *mut jvmtiEnv,
1447        jni_env: *mut JNIEnv,
1448        thread: jthread,
1449        method: jmethodID,
1450        location: jlocation,
1451        exception: jobject,
1452    ),
1453>;
1454pub type jvmtiEventFieldAccess = ::std::option::Option<
1455    unsafe extern "C" fn(
1456        jvmti_env: *mut jvmtiEnv,
1457        jni_env: *mut JNIEnv,
1458        thread: jthread,
1459        method: jmethodID,
1460        location: jlocation,
1461        field_klass: jclass,
1462        object: jobject,
1463        field: jfieldID,
1464    ),
1465>;
1466pub type jvmtiEventFieldModification = ::std::option::Option<
1467    unsafe extern "C" fn(
1468        jvmti_env: *mut jvmtiEnv,
1469        jni_env: *mut JNIEnv,
1470        thread: jthread,
1471        method: jmethodID,
1472        location: jlocation,
1473        field_klass: jclass,
1474        object: jobject,
1475        field: jfieldID,
1476        signature_type: ::std::os::raw::c_char,
1477        new_value: jvalue,
1478    ),
1479>;
1480pub type jvmtiEventFramePop = ::std::option::Option<
1481    unsafe extern "C" fn(
1482        jvmti_env: *mut jvmtiEnv,
1483        jni_env: *mut JNIEnv,
1484        thread: jthread,
1485        method: jmethodID,
1486        was_popped_by_exception: jboolean,
1487    ),
1488>;
1489pub type jvmtiEventGarbageCollectionFinish =
1490    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv)>;
1491pub type jvmtiEventGarbageCollectionStart =
1492    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv)>;
1493pub type jvmtiEventMethodEntry = ::std::option::Option<
1494    unsafe extern "C" fn(
1495        jvmti_env: *mut jvmtiEnv,
1496        jni_env: *mut JNIEnv,
1497        thread: jthread,
1498        method: jmethodID,
1499    ),
1500>;
1501pub type jvmtiEventMethodExit = ::std::option::Option<
1502    unsafe extern "C" fn(
1503        jvmti_env: *mut jvmtiEnv,
1504        jni_env: *mut JNIEnv,
1505        thread: jthread,
1506        method: jmethodID,
1507        was_popped_by_exception: jboolean,
1508        return_value: jvalue,
1509    ),
1510>;
1511pub type jvmtiEventMonitorContendedEnter = ::std::option::Option<
1512    unsafe extern "C" fn(
1513        jvmti_env: *mut jvmtiEnv,
1514        jni_env: *mut JNIEnv,
1515        thread: jthread,
1516        object: jobject,
1517    ),
1518>;
1519pub type jvmtiEventMonitorContendedEntered = ::std::option::Option<
1520    unsafe extern "C" fn(
1521        jvmti_env: *mut jvmtiEnv,
1522        jni_env: *mut JNIEnv,
1523        thread: jthread,
1524        object: jobject,
1525    ),
1526>;
1527pub type jvmtiEventMonitorWait = ::std::option::Option<
1528    unsafe extern "C" fn(
1529        jvmti_env: *mut jvmtiEnv,
1530        jni_env: *mut JNIEnv,
1531        thread: jthread,
1532        object: jobject,
1533        timeout: jlong,
1534    ),
1535>;
1536pub type jvmtiEventMonitorWaited = ::std::option::Option<
1537    unsafe extern "C" fn(
1538        jvmti_env: *mut jvmtiEnv,
1539        jni_env: *mut JNIEnv,
1540        thread: jthread,
1541        object: jobject,
1542        timed_out: jboolean,
1543    ),
1544>;
1545pub type jvmtiEventNativeMethodBind = ::std::option::Option<
1546    unsafe extern "C" fn(
1547        jvmti_env: *mut jvmtiEnv,
1548        jni_env: *mut JNIEnv,
1549        thread: jthread,
1550        method: jmethodID,
1551        address: *mut ::std::os::raw::c_void,
1552        new_address_ptr: *mut *mut ::std::os::raw::c_void,
1553    ),
1554>;
1555pub type jvmtiEventObjectFree =
1556    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, tag: jlong)>;
1557pub type jvmtiEventResourceExhausted = ::std::option::Option<
1558    unsafe extern "C" fn(
1559        jvmti_env: *mut jvmtiEnv,
1560        jni_env: *mut JNIEnv,
1561        flags: jint,
1562        reserved: *const ::std::os::raw::c_void,
1563        description: *const ::std::os::raw::c_char,
1564    ),
1565>;
1566pub type jvmtiEventSampledObjectAlloc = ::std::option::Option<
1567    unsafe extern "C" fn(
1568        jvmti_env: *mut jvmtiEnv,
1569        jni_env: *mut JNIEnv,
1570        thread: jthread,
1571        object: jobject,
1572        object_klass: jclass,
1573        size: jlong,
1574    ),
1575>;
1576pub type jvmtiEventSingleStep = ::std::option::Option<
1577    unsafe extern "C" fn(
1578        jvmti_env: *mut jvmtiEnv,
1579        jni_env: *mut JNIEnv,
1580        thread: jthread,
1581        method: jmethodID,
1582        location: jlocation,
1583    ),
1584>;
1585pub type jvmtiEventThreadEnd = ::std::option::Option<
1586    unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, jni_env: *mut JNIEnv, thread: jthread),
1587>;
1588pub type jvmtiEventThreadStart = ::std::option::Option<
1589    unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, jni_env: *mut JNIEnv, thread: jthread),
1590>;
1591pub type jvmtiEventVMDeath =
1592    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, jni_env: *mut JNIEnv)>;
1593pub type jvmtiEventVMInit = ::std::option::Option<
1594    unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, jni_env: *mut JNIEnv, thread: jthread),
1595>;
1596pub type jvmtiEventVMObjectAlloc = ::std::option::Option<
1597    unsafe extern "C" fn(
1598        jvmti_env: *mut jvmtiEnv,
1599        jni_env: *mut JNIEnv,
1600        thread: jthread,
1601        object: jobject,
1602        object_klass: jclass,
1603        size: jlong,
1604    ),
1605>;
1606pub type jvmtiEventVMStart =
1607    ::std::option::Option<unsafe extern "C" fn(jvmti_env: *mut jvmtiEnv, jni_env: *mut JNIEnv)>;
1608#[repr(C)]
1609#[derive(Debug, Copy, Clone)]
1610pub struct jvmtiEventCallbacks {
1611    pub VMInit: jvmtiEventVMInit,
1612    pub VMDeath: jvmtiEventVMDeath,
1613    pub ThreadStart: jvmtiEventThreadStart,
1614    pub ThreadEnd: jvmtiEventThreadEnd,
1615    pub ClassFileLoadHook: jvmtiEventClassFileLoadHook,
1616    pub ClassLoad: jvmtiEventClassLoad,
1617    pub ClassPrepare: jvmtiEventClassPrepare,
1618    pub VMStart: jvmtiEventVMStart,
1619    pub Exception: jvmtiEventException,
1620    pub ExceptionCatch: jvmtiEventExceptionCatch,
1621    pub SingleStep: jvmtiEventSingleStep,
1622    pub FramePop: jvmtiEventFramePop,
1623    pub Breakpoint: jvmtiEventBreakpoint,
1624    pub FieldAccess: jvmtiEventFieldAccess,
1625    pub FieldModification: jvmtiEventFieldModification,
1626    pub MethodEntry: jvmtiEventMethodEntry,
1627    pub MethodExit: jvmtiEventMethodExit,
1628    pub NativeMethodBind: jvmtiEventNativeMethodBind,
1629    pub CompiledMethodLoad: jvmtiEventCompiledMethodLoad,
1630    pub CompiledMethodUnload: jvmtiEventCompiledMethodUnload,
1631    pub DynamicCodeGenerated: jvmtiEventDynamicCodeGenerated,
1632    pub DataDumpRequest: jvmtiEventDataDumpRequest,
1633    pub reserved72: jvmtiEventReserved,
1634    pub MonitorWait: jvmtiEventMonitorWait,
1635    pub MonitorWaited: jvmtiEventMonitorWaited,
1636    pub MonitorContendedEnter: jvmtiEventMonitorContendedEnter,
1637    pub MonitorContendedEntered: jvmtiEventMonitorContendedEntered,
1638    pub reserved77: jvmtiEventReserved,
1639    pub reserved78: jvmtiEventReserved,
1640    pub reserved79: jvmtiEventReserved,
1641    pub ResourceExhausted: jvmtiEventResourceExhausted,
1642    pub GarbageCollectionStart: jvmtiEventGarbageCollectionStart,
1643    pub GarbageCollectionFinish: jvmtiEventGarbageCollectionFinish,
1644    pub ObjectFree: jvmtiEventObjectFree,
1645    pub VMObjectAlloc: jvmtiEventVMObjectAlloc,
1646    pub reserved85: jvmtiEventReserved,
1647    pub SampledObjectAlloc: jvmtiEventSampledObjectAlloc,
1648}
1649#[repr(C)]
1650#[derive(Debug, Copy, Clone)]
1651pub struct jvmtiInterface_1_ {
1652    pub reserved1: *mut ::std::os::raw::c_void,
1653    pub SetEventNotificationMode: ::std::option::Option<
1654        unsafe extern "C" fn(
1655            env: *mut jvmtiEnv,
1656            mode: jvmtiEventMode,
1657            event_type: jvmtiEvent,
1658            event_thread: jthread,
1659            ...
1660        ) -> jvmtiError,
1661    >,
1662    pub GetAllModules: ::std::option::Option<
1663        unsafe extern "C" fn(
1664            env: *mut jvmtiEnv,
1665            module_count_ptr: *mut jint,
1666            modules_ptr: *mut *mut jobject,
1667        ) -> jvmtiError,
1668    >,
1669    pub GetAllThreads: ::std::option::Option<
1670        unsafe extern "C" fn(
1671            env: *mut jvmtiEnv,
1672            threads_count_ptr: *mut jint,
1673            threads_ptr: *mut *mut jthread,
1674        ) -> jvmtiError,
1675    >,
1676    pub SuspendThread: ::std::option::Option<
1677        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread) -> jvmtiError,
1678    >,
1679    pub ResumeThread: ::std::option::Option<
1680        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread) -> jvmtiError,
1681    >,
1682    pub StopThread: ::std::option::Option<
1683        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, exception: jobject) -> jvmtiError,
1684    >,
1685    pub InterruptThread: ::std::option::Option<
1686        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread) -> jvmtiError,
1687    >,
1688    pub GetThreadInfo: ::std::option::Option<
1689        unsafe extern "C" fn(
1690            env: *mut jvmtiEnv,
1691            thread: jthread,
1692            info_ptr: *mut jvmtiThreadInfo,
1693        ) -> jvmtiError,
1694    >,
1695    pub GetOwnedMonitorInfo: ::std::option::Option<
1696        unsafe extern "C" fn(
1697            env: *mut jvmtiEnv,
1698            thread: jthread,
1699            owned_monitor_count_ptr: *mut jint,
1700            owned_monitors_ptr: *mut *mut jobject,
1701        ) -> jvmtiError,
1702    >,
1703    pub GetCurrentContendedMonitor: ::std::option::Option<
1704        unsafe extern "C" fn(
1705            env: *mut jvmtiEnv,
1706            thread: jthread,
1707            monitor_ptr: *mut jobject,
1708        ) -> jvmtiError,
1709    >,
1710    pub RunAgentThread: ::std::option::Option<
1711        unsafe extern "C" fn(
1712            env: *mut jvmtiEnv,
1713            thread: jthread,
1714            proc_: jvmtiStartFunction,
1715            arg: *const ::std::os::raw::c_void,
1716            priority: jint,
1717        ) -> jvmtiError,
1718    >,
1719    pub GetTopThreadGroups: ::std::option::Option<
1720        unsafe extern "C" fn(
1721            env: *mut jvmtiEnv,
1722            group_count_ptr: *mut jint,
1723            groups_ptr: *mut *mut jthreadGroup,
1724        ) -> jvmtiError,
1725    >,
1726    pub GetThreadGroupInfo: ::std::option::Option<
1727        unsafe extern "C" fn(
1728            env: *mut jvmtiEnv,
1729            group: jthreadGroup,
1730            info_ptr: *mut jvmtiThreadGroupInfo,
1731        ) -> jvmtiError,
1732    >,
1733    pub GetThreadGroupChildren: ::std::option::Option<
1734        unsafe extern "C" fn(
1735            env: *mut jvmtiEnv,
1736            group: jthreadGroup,
1737            thread_count_ptr: *mut jint,
1738            threads_ptr: *mut *mut jthread,
1739            group_count_ptr: *mut jint,
1740            groups_ptr: *mut *mut jthreadGroup,
1741        ) -> jvmtiError,
1742    >,
1743    pub GetFrameCount: ::std::option::Option<
1744        unsafe extern "C" fn(
1745            env: *mut jvmtiEnv,
1746            thread: jthread,
1747            count_ptr: *mut jint,
1748        ) -> jvmtiError,
1749    >,
1750    pub GetThreadState: ::std::option::Option<
1751        unsafe extern "C" fn(
1752            env: *mut jvmtiEnv,
1753            thread: jthread,
1754            thread_state_ptr: *mut jint,
1755        ) -> jvmtiError,
1756    >,
1757    pub GetCurrentThread: ::std::option::Option<
1758        unsafe extern "C" fn(env: *mut jvmtiEnv, thread_ptr: *mut jthread) -> jvmtiError,
1759    >,
1760    pub GetFrameLocation: ::std::option::Option<
1761        unsafe extern "C" fn(
1762            env: *mut jvmtiEnv,
1763            thread: jthread,
1764            depth: jint,
1765            method_ptr: *mut jmethodID,
1766            location_ptr: *mut jlocation,
1767        ) -> jvmtiError,
1768    >,
1769    pub NotifyFramePop: ::std::option::Option<
1770        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, depth: jint) -> jvmtiError,
1771    >,
1772    pub GetLocalObject: ::std::option::Option<
1773        unsafe extern "C" fn(
1774            env: *mut jvmtiEnv,
1775            thread: jthread,
1776            depth: jint,
1777            slot: jint,
1778            value_ptr: *mut jobject,
1779        ) -> jvmtiError,
1780    >,
1781    pub GetLocalInt: ::std::option::Option<
1782        unsafe extern "C" fn(
1783            env: *mut jvmtiEnv,
1784            thread: jthread,
1785            depth: jint,
1786            slot: jint,
1787            value_ptr: *mut jint,
1788        ) -> jvmtiError,
1789    >,
1790    pub GetLocalLong: ::std::option::Option<
1791        unsafe extern "C" fn(
1792            env: *mut jvmtiEnv,
1793            thread: jthread,
1794            depth: jint,
1795            slot: jint,
1796            value_ptr: *mut jlong,
1797        ) -> jvmtiError,
1798    >,
1799    pub GetLocalFloat: ::std::option::Option<
1800        unsafe extern "C" fn(
1801            env: *mut jvmtiEnv,
1802            thread: jthread,
1803            depth: jint,
1804            slot: jint,
1805            value_ptr: *mut jfloat,
1806        ) -> jvmtiError,
1807    >,
1808    pub GetLocalDouble: ::std::option::Option<
1809        unsafe extern "C" fn(
1810            env: *mut jvmtiEnv,
1811            thread: jthread,
1812            depth: jint,
1813            slot: jint,
1814            value_ptr: *mut jdouble,
1815        ) -> jvmtiError,
1816    >,
1817    pub SetLocalObject: ::std::option::Option<
1818        unsafe extern "C" fn(
1819            env: *mut jvmtiEnv,
1820            thread: jthread,
1821            depth: jint,
1822            slot: jint,
1823            value: jobject,
1824        ) -> jvmtiError,
1825    >,
1826    pub SetLocalInt: ::std::option::Option<
1827        unsafe extern "C" fn(
1828            env: *mut jvmtiEnv,
1829            thread: jthread,
1830            depth: jint,
1831            slot: jint,
1832            value: jint,
1833        ) -> jvmtiError,
1834    >,
1835    pub SetLocalLong: ::std::option::Option<
1836        unsafe extern "C" fn(
1837            env: *mut jvmtiEnv,
1838            thread: jthread,
1839            depth: jint,
1840            slot: jint,
1841            value: jlong,
1842        ) -> jvmtiError,
1843    >,
1844    pub SetLocalFloat: ::std::option::Option<
1845        unsafe extern "C" fn(
1846            env: *mut jvmtiEnv,
1847            thread: jthread,
1848            depth: jint,
1849            slot: jint,
1850            value: jfloat,
1851        ) -> jvmtiError,
1852    >,
1853    pub SetLocalDouble: ::std::option::Option<
1854        unsafe extern "C" fn(
1855            env: *mut jvmtiEnv,
1856            thread: jthread,
1857            depth: jint,
1858            slot: jint,
1859            value: jdouble,
1860        ) -> jvmtiError,
1861    >,
1862    pub CreateRawMonitor: ::std::option::Option<
1863        unsafe extern "C" fn(
1864            env: *mut jvmtiEnv,
1865            name: *const ::std::os::raw::c_char,
1866            monitor_ptr: *mut jrawMonitorID,
1867        ) -> jvmtiError,
1868    >,
1869    pub DestroyRawMonitor: ::std::option::Option<
1870        unsafe extern "C" fn(env: *mut jvmtiEnv, monitor: jrawMonitorID) -> jvmtiError,
1871    >,
1872    pub RawMonitorEnter: ::std::option::Option<
1873        unsafe extern "C" fn(env: *mut jvmtiEnv, monitor: jrawMonitorID) -> jvmtiError,
1874    >,
1875    pub RawMonitorExit: ::std::option::Option<
1876        unsafe extern "C" fn(env: *mut jvmtiEnv, monitor: jrawMonitorID) -> jvmtiError,
1877    >,
1878    pub RawMonitorWait: ::std::option::Option<
1879        unsafe extern "C" fn(
1880            env: *mut jvmtiEnv,
1881            monitor: jrawMonitorID,
1882            millis: jlong,
1883        ) -> jvmtiError,
1884    >,
1885    pub RawMonitorNotify: ::std::option::Option<
1886        unsafe extern "C" fn(env: *mut jvmtiEnv, monitor: jrawMonitorID) -> jvmtiError,
1887    >,
1888    pub RawMonitorNotifyAll: ::std::option::Option<
1889        unsafe extern "C" fn(env: *mut jvmtiEnv, monitor: jrawMonitorID) -> jvmtiError,
1890    >,
1891    pub SetBreakpoint: ::std::option::Option<
1892        unsafe extern "C" fn(
1893            env: *mut jvmtiEnv,
1894            method: jmethodID,
1895            location: jlocation,
1896        ) -> jvmtiError,
1897    >,
1898    pub ClearBreakpoint: ::std::option::Option<
1899        unsafe extern "C" fn(
1900            env: *mut jvmtiEnv,
1901            method: jmethodID,
1902            location: jlocation,
1903        ) -> jvmtiError,
1904    >,
1905    pub GetNamedModule: ::std::option::Option<
1906        unsafe extern "C" fn(
1907            env: *mut jvmtiEnv,
1908            class_loader: jobject,
1909            package_name: *const ::std::os::raw::c_char,
1910            module_ptr: *mut jobject,
1911        ) -> jvmtiError,
1912    >,
1913    pub SetFieldAccessWatch: ::std::option::Option<
1914        unsafe extern "C" fn(env: *mut jvmtiEnv, klass: jclass, field: jfieldID) -> jvmtiError,
1915    >,
1916    pub ClearFieldAccessWatch: ::std::option::Option<
1917        unsafe extern "C" fn(env: *mut jvmtiEnv, klass: jclass, field: jfieldID) -> jvmtiError,
1918    >,
1919    pub SetFieldModificationWatch: ::std::option::Option<
1920        unsafe extern "C" fn(env: *mut jvmtiEnv, klass: jclass, field: jfieldID) -> jvmtiError,
1921    >,
1922    pub ClearFieldModificationWatch: ::std::option::Option<
1923        unsafe extern "C" fn(env: *mut jvmtiEnv, klass: jclass, field: jfieldID) -> jvmtiError,
1924    >,
1925    pub IsModifiableClass: ::std::option::Option<
1926        unsafe extern "C" fn(
1927            env: *mut jvmtiEnv,
1928            klass: jclass,
1929            is_modifiable_class_ptr: *mut jboolean,
1930        ) -> jvmtiError,
1931    >,
1932    pub Allocate: ::std::option::Option<
1933        unsafe extern "C" fn(
1934            env: *mut jvmtiEnv,
1935            size: jlong,
1936            mem_ptr: *mut *mut ::std::os::raw::c_uchar,
1937        ) -> jvmtiError,
1938    >,
1939    pub Deallocate: ::std::option::Option<
1940        unsafe extern "C" fn(env: *mut jvmtiEnv, mem: *mut ::std::os::raw::c_uchar) -> jvmtiError,
1941    >,
1942    pub GetClassSignature: ::std::option::Option<
1943        unsafe extern "C" fn(
1944            env: *mut jvmtiEnv,
1945            klass: jclass,
1946            signature_ptr: *mut *mut ::std::os::raw::c_char,
1947            generic_ptr: *mut *mut ::std::os::raw::c_char,
1948        ) -> jvmtiError,
1949    >,
1950    pub GetClassStatus: ::std::option::Option<
1951        unsafe extern "C" fn(
1952            env: *mut jvmtiEnv,
1953            klass: jclass,
1954            status_ptr: *mut jint,
1955        ) -> jvmtiError,
1956    >,
1957    pub GetSourceFileName: ::std::option::Option<
1958        unsafe extern "C" fn(
1959            env: *mut jvmtiEnv,
1960            klass: jclass,
1961            source_name_ptr: *mut *mut ::std::os::raw::c_char,
1962        ) -> jvmtiError,
1963    >,
1964    pub GetClassModifiers: ::std::option::Option<
1965        unsafe extern "C" fn(
1966            env: *mut jvmtiEnv,
1967            klass: jclass,
1968            modifiers_ptr: *mut jint,
1969        ) -> jvmtiError,
1970    >,
1971    pub GetClassMethods: ::std::option::Option<
1972        unsafe extern "C" fn(
1973            env: *mut jvmtiEnv,
1974            klass: jclass,
1975            method_count_ptr: *mut jint,
1976            methods_ptr: *mut *mut jmethodID,
1977        ) -> jvmtiError,
1978    >,
1979    pub GetClassFields: ::std::option::Option<
1980        unsafe extern "C" fn(
1981            env: *mut jvmtiEnv,
1982            klass: jclass,
1983            field_count_ptr: *mut jint,
1984            fields_ptr: *mut *mut jfieldID,
1985        ) -> jvmtiError,
1986    >,
1987    pub GetImplementedInterfaces: ::std::option::Option<
1988        unsafe extern "C" fn(
1989            env: *mut jvmtiEnv,
1990            klass: jclass,
1991            interface_count_ptr: *mut jint,
1992            interfaces_ptr: *mut *mut jclass,
1993        ) -> jvmtiError,
1994    >,
1995    pub IsInterface: ::std::option::Option<
1996        unsafe extern "C" fn(
1997            env: *mut jvmtiEnv,
1998            klass: jclass,
1999            is_interface_ptr: *mut jboolean,
2000        ) -> jvmtiError,
2001    >,
2002    pub IsArrayClass: ::std::option::Option<
2003        unsafe extern "C" fn(
2004            env: *mut jvmtiEnv,
2005            klass: jclass,
2006            is_array_class_ptr: *mut jboolean,
2007        ) -> jvmtiError,
2008    >,
2009    pub GetClassLoader: ::std::option::Option<
2010        unsafe extern "C" fn(
2011            env: *mut jvmtiEnv,
2012            klass: jclass,
2013            classloader_ptr: *mut jobject,
2014        ) -> jvmtiError,
2015    >,
2016    pub GetObjectHashCode: ::std::option::Option<
2017        unsafe extern "C" fn(
2018            env: *mut jvmtiEnv,
2019            object: jobject,
2020            hash_code_ptr: *mut jint,
2021        ) -> jvmtiError,
2022    >,
2023    pub GetObjectMonitorUsage: ::std::option::Option<
2024        unsafe extern "C" fn(
2025            env: *mut jvmtiEnv,
2026            object: jobject,
2027            info_ptr: *mut jvmtiMonitorUsage,
2028        ) -> jvmtiError,
2029    >,
2030    pub GetFieldName: ::std::option::Option<
2031        unsafe extern "C" fn(
2032            env: *mut jvmtiEnv,
2033            klass: jclass,
2034            field: jfieldID,
2035            name_ptr: *mut *mut ::std::os::raw::c_char,
2036            signature_ptr: *mut *mut ::std::os::raw::c_char,
2037            generic_ptr: *mut *mut ::std::os::raw::c_char,
2038        ) -> jvmtiError,
2039    >,
2040    pub GetFieldDeclaringClass: ::std::option::Option<
2041        unsafe extern "C" fn(
2042            env: *mut jvmtiEnv,
2043            klass: jclass,
2044            field: jfieldID,
2045            declaring_class_ptr: *mut jclass,
2046        ) -> jvmtiError,
2047    >,
2048    pub GetFieldModifiers: ::std::option::Option<
2049        unsafe extern "C" fn(
2050            env: *mut jvmtiEnv,
2051            klass: jclass,
2052            field: jfieldID,
2053            modifiers_ptr: *mut jint,
2054        ) -> jvmtiError,
2055    >,
2056    pub IsFieldSynthetic: ::std::option::Option<
2057        unsafe extern "C" fn(
2058            env: *mut jvmtiEnv,
2059            klass: jclass,
2060            field: jfieldID,
2061            is_synthetic_ptr: *mut jboolean,
2062        ) -> jvmtiError,
2063    >,
2064    pub GetMethodName: ::std::option::Option<
2065        unsafe extern "C" fn(
2066            env: *mut jvmtiEnv,
2067            method: jmethodID,
2068            name_ptr: *mut *mut ::std::os::raw::c_char,
2069            signature_ptr: *mut *mut ::std::os::raw::c_char,
2070            generic_ptr: *mut *mut ::std::os::raw::c_char,
2071        ) -> jvmtiError,
2072    >,
2073    pub GetMethodDeclaringClass: ::std::option::Option<
2074        unsafe extern "C" fn(
2075            env: *mut jvmtiEnv,
2076            method: jmethodID,
2077            declaring_class_ptr: *mut jclass,
2078        ) -> jvmtiError,
2079    >,
2080    pub GetMethodModifiers: ::std::option::Option<
2081        unsafe extern "C" fn(
2082            env: *mut jvmtiEnv,
2083            method: jmethodID,
2084            modifiers_ptr: *mut jint,
2085        ) -> jvmtiError,
2086    >,
2087    pub reserved67: *mut ::std::os::raw::c_void,
2088    pub GetMaxLocals: ::std::option::Option<
2089        unsafe extern "C" fn(
2090            env: *mut jvmtiEnv,
2091            method: jmethodID,
2092            max_ptr: *mut jint,
2093        ) -> jvmtiError,
2094    >,
2095    pub GetArgumentsSize: ::std::option::Option<
2096        unsafe extern "C" fn(
2097            env: *mut jvmtiEnv,
2098            method: jmethodID,
2099            size_ptr: *mut jint,
2100        ) -> jvmtiError,
2101    >,
2102    pub GetLineNumberTable: ::std::option::Option<
2103        unsafe extern "C" fn(
2104            env: *mut jvmtiEnv,
2105            method: jmethodID,
2106            entry_count_ptr: *mut jint,
2107            table_ptr: *mut *mut jvmtiLineNumberEntry,
2108        ) -> jvmtiError,
2109    >,
2110    pub GetMethodLocation: ::std::option::Option<
2111        unsafe extern "C" fn(
2112            env: *mut jvmtiEnv,
2113            method: jmethodID,
2114            start_location_ptr: *mut jlocation,
2115            end_location_ptr: *mut jlocation,
2116        ) -> jvmtiError,
2117    >,
2118    pub GetLocalVariableTable: ::std::option::Option<
2119        unsafe extern "C" fn(
2120            env: *mut jvmtiEnv,
2121            method: jmethodID,
2122            entry_count_ptr: *mut jint,
2123            table_ptr: *mut *mut jvmtiLocalVariableEntry,
2124        ) -> jvmtiError,
2125    >,
2126    pub SetNativeMethodPrefix: ::std::option::Option<
2127        unsafe extern "C" fn(
2128            env: *mut jvmtiEnv,
2129            prefix: *const ::std::os::raw::c_char,
2130        ) -> jvmtiError,
2131    >,
2132    pub SetNativeMethodPrefixes: ::std::option::Option<
2133        unsafe extern "C" fn(
2134            env: *mut jvmtiEnv,
2135            prefix_count: jint,
2136            prefixes: *mut *mut ::std::os::raw::c_char,
2137        ) -> jvmtiError,
2138    >,
2139    pub GetBytecodes: ::std::option::Option<
2140        unsafe extern "C" fn(
2141            env: *mut jvmtiEnv,
2142            method: jmethodID,
2143            bytecode_count_ptr: *mut jint,
2144            bytecodes_ptr: *mut *mut ::std::os::raw::c_uchar,
2145        ) -> jvmtiError,
2146    >,
2147    pub IsMethodNative: ::std::option::Option<
2148        unsafe extern "C" fn(
2149            env: *mut jvmtiEnv,
2150            method: jmethodID,
2151            is_native_ptr: *mut jboolean,
2152        ) -> jvmtiError,
2153    >,
2154    pub IsMethodSynthetic: ::std::option::Option<
2155        unsafe extern "C" fn(
2156            env: *mut jvmtiEnv,
2157            method: jmethodID,
2158            is_synthetic_ptr: *mut jboolean,
2159        ) -> jvmtiError,
2160    >,
2161    pub GetLoadedClasses: ::std::option::Option<
2162        unsafe extern "C" fn(
2163            env: *mut jvmtiEnv,
2164            class_count_ptr: *mut jint,
2165            classes_ptr: *mut *mut jclass,
2166        ) -> jvmtiError,
2167    >,
2168    pub GetClassLoaderClasses: ::std::option::Option<
2169        unsafe extern "C" fn(
2170            env: *mut jvmtiEnv,
2171            initiating_loader: jobject,
2172            class_count_ptr: *mut jint,
2173            classes_ptr: *mut *mut jclass,
2174        ) -> jvmtiError,
2175    >,
2176    pub PopFrame: ::std::option::Option<
2177        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread) -> jvmtiError,
2178    >,
2179    pub ForceEarlyReturnObject: ::std::option::Option<
2180        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, value: jobject) -> jvmtiError,
2181    >,
2182    pub ForceEarlyReturnInt: ::std::option::Option<
2183        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, value: jint) -> jvmtiError,
2184    >,
2185    pub ForceEarlyReturnLong: ::std::option::Option<
2186        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, value: jlong) -> jvmtiError,
2187    >,
2188    pub ForceEarlyReturnFloat: ::std::option::Option<
2189        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, value: jfloat) -> jvmtiError,
2190    >,
2191    pub ForceEarlyReturnDouble: ::std::option::Option<
2192        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread, value: jdouble) -> jvmtiError,
2193    >,
2194    pub ForceEarlyReturnVoid: ::std::option::Option<
2195        unsafe extern "C" fn(env: *mut jvmtiEnv, thread: jthread) -> jvmtiError,
2196    >,
2197    pub RedefineClasses: ::std::option::Option<
2198        unsafe extern "C" fn(
2199            env: *mut jvmtiEnv,
2200            class_count: jint,
2201            class_definitions: *const jvmtiClassDefinition,
2202        ) -> jvmtiError,
2203    >,
2204    pub GetVersionNumber: ::std::option::Option<
2205        unsafe extern "C" fn(env: *mut jvmtiEnv, version_ptr: *mut jint) -> jvmtiError,
2206    >,
2207    pub GetCapabilities: ::std::option::Option<
2208        unsafe extern "C" fn(
2209            env: *mut jvmtiEnv,
2210            capabilities_ptr: *mut jvmtiCapabilities,
2211        ) -> jvmtiError,
2212    >,
2213    pub GetSourceDebugExtension: ::std::option::Option<
2214        unsafe extern "C" fn(
2215            env: *mut jvmtiEnv,
2216            klass: jclass,
2217            source_debug_extension_ptr: *mut *mut ::std::os::raw::c_char,
2218        ) -> jvmtiError,
2219    >,
2220    pub IsMethodObsolete: ::std::option::Option<
2221        unsafe extern "C" fn(
2222            env: *mut jvmtiEnv,
2223            method: jmethodID,
2224            is_obsolete_ptr: *mut jboolean,
2225        ) -> jvmtiError,
2226    >,
2227    pub SuspendThreadList: ::std::option::Option<
2228        unsafe extern "C" fn(
2229            env: *mut jvmtiEnv,
2230            request_count: jint,
2231            request_list: *const jthread,
2232            results: *mut jvmtiError,
2233        ) -> jvmtiError,
2234    >,
2235    pub ResumeThreadList: ::std::option::Option<
2236        unsafe extern "C" fn(
2237            env: *mut jvmtiEnv,
2238            request_count: jint,
2239            request_list: *const jthread,
2240            results: *mut jvmtiError,
2241        ) -> jvmtiError,
2242    >,
2243    pub AddModuleReads: ::std::option::Option<
2244        unsafe extern "C" fn(env: *mut jvmtiEnv, module: jobject, to_module: jobject) -> jvmtiError,
2245    >,
2246    pub AddModuleExports: ::std::option::Option<
2247        unsafe extern "C" fn(
2248            env: *mut jvmtiEnv,
2249            module: jobject,
2250            pkg_name: *const ::std::os::raw::c_char,
2251            to_module: jobject,
2252        ) -> jvmtiError,
2253    >,
2254    pub AddModuleOpens: ::std::option::Option<
2255        unsafe extern "C" fn(
2256            env: *mut jvmtiEnv,
2257            module: jobject,
2258            pkg_name: *const ::std::os::raw::c_char,
2259            to_module: jobject,
2260        ) -> jvmtiError,
2261    >,
2262    pub AddModuleUses: ::std::option::Option<
2263        unsafe extern "C" fn(env: *mut jvmtiEnv, module: jobject, service: jclass) -> jvmtiError,
2264    >,
2265    pub AddModuleProvides: ::std::option::Option<
2266        unsafe extern "C" fn(
2267            env: *mut jvmtiEnv,
2268            module: jobject,
2269            service: jclass,
2270            impl_class: jclass,
2271        ) -> jvmtiError,
2272    >,
2273    pub IsModifiableModule: ::std::option::Option<
2274        unsafe extern "C" fn(
2275            env: *mut jvmtiEnv,
2276            module: jobject,
2277            is_modifiable_module_ptr: *mut jboolean,
2278        ) -> jvmtiError,
2279    >,
2280    pub GetAllStackTraces: ::std::option::Option<
2281        unsafe extern "C" fn(
2282            env: *mut jvmtiEnv,
2283            max_frame_count: jint,
2284            stack_info_ptr: *mut *mut jvmtiStackInfo,
2285            thread_count_ptr: *mut jint,
2286        ) -> jvmtiError,
2287    >,
2288    pub GetThreadListStackTraces: ::std::option::Option<
2289        unsafe extern "C" fn(
2290            env: *mut jvmtiEnv,
2291            thread_count: jint,
2292            thread_list: *const jthread,
2293            max_frame_count: jint,
2294            stack_info_ptr: *mut *mut jvmtiStackInfo,
2295        ) -> jvmtiError,
2296    >,
2297    pub GetThreadLocalStorage: ::std::option::Option<
2298        unsafe extern "C" fn(
2299            env: *mut jvmtiEnv,
2300            thread: jthread,
2301            data_ptr: *mut *mut ::std::os::raw::c_void,
2302        ) -> jvmtiError,
2303    >,
2304    pub SetThreadLocalStorage: ::std::option::Option<
2305        unsafe extern "C" fn(
2306            env: *mut jvmtiEnv,
2307            thread: jthread,
2308            data: *const ::std::os::raw::c_void,
2309        ) -> jvmtiError,
2310    >,
2311    pub GetStackTrace: ::std::option::Option<
2312        unsafe extern "C" fn(
2313            env: *mut jvmtiEnv,
2314            thread: jthread,
2315            start_depth: jint,
2316            max_frame_count: jint,
2317            frame_buffer: *mut jvmtiFrameInfo,
2318            count_ptr: *mut jint,
2319        ) -> jvmtiError,
2320    >,
2321    pub reserved105: *mut ::std::os::raw::c_void,
2322    pub GetTag: ::std::option::Option<
2323        unsafe extern "C" fn(
2324            env: *mut jvmtiEnv,
2325            object: jobject,
2326            tag_ptr: *mut jlong,
2327        ) -> jvmtiError,
2328    >,
2329    pub SetTag: ::std::option::Option<
2330        unsafe extern "C" fn(env: *mut jvmtiEnv, object: jobject, tag: jlong) -> jvmtiError,
2331    >,
2332    pub ForceGarbageCollection:
2333        ::std::option::Option<unsafe extern "C" fn(env: *mut jvmtiEnv) -> jvmtiError>,
2334    pub IterateOverObjectsReachableFromObject: ::std::option::Option<
2335        unsafe extern "C" fn(
2336            env: *mut jvmtiEnv,
2337            object: jobject,
2338            object_reference_callback: jvmtiObjectReferenceCallback,
2339            user_data: *const ::std::os::raw::c_void,
2340        ) -> jvmtiError,
2341    >,
2342    pub IterateOverReachableObjects: ::std::option::Option<
2343        unsafe extern "C" fn(
2344            env: *mut jvmtiEnv,
2345            heap_root_callback: jvmtiHeapRootCallback,
2346            stack_ref_callback: jvmtiStackReferenceCallback,
2347            object_ref_callback: jvmtiObjectReferenceCallback,
2348            user_data: *const ::std::os::raw::c_void,
2349        ) -> jvmtiError,
2350    >,
2351    pub IterateOverHeap: ::std::option::Option<
2352        unsafe extern "C" fn(
2353            env: *mut jvmtiEnv,
2354            object_filter: jvmtiHeapObjectFilter,
2355            heap_object_callback: jvmtiHeapObjectCallback,
2356            user_data: *const ::std::os::raw::c_void,
2357        ) -> jvmtiError,
2358    >,
2359    pub IterateOverInstancesOfClass: ::std::option::Option<
2360        unsafe extern "C" fn(
2361            env: *mut jvmtiEnv,
2362            klass: jclass,
2363            object_filter: jvmtiHeapObjectFilter,
2364            heap_object_callback: jvmtiHeapObjectCallback,
2365            user_data: *const ::std::os::raw::c_void,
2366        ) -> jvmtiError,
2367    >,
2368    pub reserved113: *mut ::std::os::raw::c_void,
2369    pub GetObjectsWithTags: ::std::option::Option<
2370        unsafe extern "C" fn(
2371            env: *mut jvmtiEnv,
2372            tag_count: jint,
2373            tags: *const jlong,
2374            count_ptr: *mut jint,
2375            object_result_ptr: *mut *mut jobject,
2376            tag_result_ptr: *mut *mut jlong,
2377        ) -> jvmtiError,
2378    >,
2379    pub FollowReferences: ::std::option::Option<
2380        unsafe extern "C" fn(
2381            env: *mut jvmtiEnv,
2382            heap_filter: jint,
2383            klass: jclass,
2384            initial_object: jobject,
2385            callbacks: *const jvmtiHeapCallbacks,
2386            user_data: *const ::std::os::raw::c_void,
2387        ) -> jvmtiError,
2388    >,
2389    pub IterateThroughHeap: ::std::option::Option<
2390        unsafe extern "C" fn(
2391            env: *mut jvmtiEnv,
2392            heap_filter: jint,
2393            klass: jclass,
2394            callbacks: *const jvmtiHeapCallbacks,
2395            user_data: *const ::std::os::raw::c_void,
2396        ) -> jvmtiError,
2397    >,
2398    pub reserved117: *mut ::std::os::raw::c_void,
2399    pub reserved118: *mut ::std::os::raw::c_void,
2400    pub reserved119: *mut ::std::os::raw::c_void,
2401    pub SetJNIFunctionTable: ::std::option::Option<
2402        unsafe extern "C" fn(
2403            env: *mut jvmtiEnv,
2404            function_table: *const jniNativeInterface,
2405        ) -> jvmtiError,
2406    >,
2407    pub GetJNIFunctionTable: ::std::option::Option<
2408        unsafe extern "C" fn(
2409            env: *mut jvmtiEnv,
2410            function_table: *mut *mut jniNativeInterface,
2411        ) -> jvmtiError,
2412    >,
2413    pub SetEventCallbacks: ::std::option::Option<
2414        unsafe extern "C" fn(
2415            env: *mut jvmtiEnv,
2416            callbacks: *const jvmtiEventCallbacks,
2417            size_of_callbacks: jint,
2418        ) -> jvmtiError,
2419    >,
2420    pub GenerateEvents: ::std::option::Option<
2421        unsafe extern "C" fn(env: *mut jvmtiEnv, event_type: jvmtiEvent) -> jvmtiError,
2422    >,
2423    pub GetExtensionFunctions: ::std::option::Option<
2424        unsafe extern "C" fn(
2425            env: *mut jvmtiEnv,
2426            extension_count_ptr: *mut jint,
2427            extensions: *mut *mut jvmtiExtensionFunctionInfo,
2428        ) -> jvmtiError,
2429    >,
2430    pub GetExtensionEvents: ::std::option::Option<
2431        unsafe extern "C" fn(
2432            env: *mut jvmtiEnv,
2433            extension_count_ptr: *mut jint,
2434            extensions: *mut *mut jvmtiExtensionEventInfo,
2435        ) -> jvmtiError,
2436    >,
2437    pub SetExtensionEventCallback: ::std::option::Option<
2438        unsafe extern "C" fn(
2439            env: *mut jvmtiEnv,
2440            extension_event_index: jint,
2441            callback: jvmtiExtensionEvent,
2442        ) -> jvmtiError,
2443    >,
2444    pub DisposeEnvironment:
2445        ::std::option::Option<unsafe extern "C" fn(env: *mut jvmtiEnv) -> jvmtiError>,
2446    pub GetErrorName: ::std::option::Option<
2447        unsafe extern "C" fn(
2448            env: *mut jvmtiEnv,
2449            error: jvmtiError,
2450            name_ptr: *mut *mut ::std::os::raw::c_char,
2451        ) -> jvmtiError,
2452    >,
2453    pub GetJLocationFormat: ::std::option::Option<
2454        unsafe extern "C" fn(
2455            env: *mut jvmtiEnv,
2456            format_ptr: *mut jvmtiJlocationFormat,
2457        ) -> jvmtiError,
2458    >,
2459    pub GetSystemProperties: ::std::option::Option<
2460        unsafe extern "C" fn(
2461            env: *mut jvmtiEnv,
2462            count_ptr: *mut jint,
2463            property_ptr: *mut *mut *mut ::std::os::raw::c_char,
2464        ) -> jvmtiError,
2465    >,
2466    pub GetSystemProperty: ::std::option::Option<
2467        unsafe extern "C" fn(
2468            env: *mut jvmtiEnv,
2469            property: *const ::std::os::raw::c_char,
2470            value_ptr: *mut *mut ::std::os::raw::c_char,
2471        ) -> jvmtiError,
2472    >,
2473    pub SetSystemProperty: ::std::option::Option<
2474        unsafe extern "C" fn(
2475            env: *mut jvmtiEnv,
2476            property: *const ::std::os::raw::c_char,
2477            value_ptr: *const ::std::os::raw::c_char,
2478        ) -> jvmtiError,
2479    >,
2480    pub GetPhase: ::std::option::Option<
2481        unsafe extern "C" fn(env: *mut jvmtiEnv, phase_ptr: *mut jvmtiPhase) -> jvmtiError,
2482    >,
2483    pub GetCurrentThreadCpuTimerInfo: ::std::option::Option<
2484        unsafe extern "C" fn(env: *mut jvmtiEnv, info_ptr: *mut jvmtiTimerInfo) -> jvmtiError,
2485    >,
2486    pub GetCurrentThreadCpuTime: ::std::option::Option<
2487        unsafe extern "C" fn(env: *mut jvmtiEnv, nanos_ptr: *mut jlong) -> jvmtiError,
2488    >,
2489    pub GetThreadCpuTimerInfo: ::std::option::Option<
2490        unsafe extern "C" fn(env: *mut jvmtiEnv, info_ptr: *mut jvmtiTimerInfo) -> jvmtiError,
2491    >,
2492    pub GetThreadCpuTime: ::std::option::Option<
2493        unsafe extern "C" fn(
2494            env: *mut jvmtiEnv,
2495            thread: jthread,
2496            nanos_ptr: *mut jlong,
2497        ) -> jvmtiError,
2498    >,
2499    pub GetTimerInfo: ::std::option::Option<
2500        unsafe extern "C" fn(env: *mut jvmtiEnv, info_ptr: *mut jvmtiTimerInfo) -> jvmtiError,
2501    >,
2502    pub GetTime: ::std::option::Option<
2503        unsafe extern "C" fn(env: *mut jvmtiEnv, nanos_ptr: *mut jlong) -> jvmtiError,
2504    >,
2505    pub GetPotentialCapabilities: ::std::option::Option<
2506        unsafe extern "C" fn(
2507            env: *mut jvmtiEnv,
2508            capabilities_ptr: *mut jvmtiCapabilities,
2509        ) -> jvmtiError,
2510    >,
2511    pub reserved141: *mut ::std::os::raw::c_void,
2512    pub AddCapabilities: ::std::option::Option<
2513        unsafe extern "C" fn(
2514            env: *mut jvmtiEnv,
2515            capabilities_ptr: *const jvmtiCapabilities,
2516        ) -> jvmtiError,
2517    >,
2518    pub RelinquishCapabilities: ::std::option::Option<
2519        unsafe extern "C" fn(
2520            env: *mut jvmtiEnv,
2521            capabilities_ptr: *const jvmtiCapabilities,
2522        ) -> jvmtiError,
2523    >,
2524    pub GetAvailableProcessors: ::std::option::Option<
2525        unsafe extern "C" fn(env: *mut jvmtiEnv, processor_count_ptr: *mut jint) -> jvmtiError,
2526    >,
2527    pub GetClassVersionNumbers: ::std::option::Option<
2528        unsafe extern "C" fn(
2529            env: *mut jvmtiEnv,
2530            klass: jclass,
2531            minor_version_ptr: *mut jint,
2532            major_version_ptr: *mut jint,
2533        ) -> jvmtiError,
2534    >,
2535    pub GetConstantPool: ::std::option::Option<
2536        unsafe extern "C" fn(
2537            env: *mut jvmtiEnv,
2538            klass: jclass,
2539            constant_pool_count_ptr: *mut jint,
2540            constant_pool_byte_count_ptr: *mut jint,
2541            constant_pool_bytes_ptr: *mut *mut ::std::os::raw::c_uchar,
2542        ) -> jvmtiError,
2543    >,
2544    pub GetEnvironmentLocalStorage: ::std::option::Option<
2545        unsafe extern "C" fn(
2546            env: *mut jvmtiEnv,
2547            data_ptr: *mut *mut ::std::os::raw::c_void,
2548        ) -> jvmtiError,
2549    >,
2550    pub SetEnvironmentLocalStorage: ::std::option::Option<
2551        unsafe extern "C" fn(env: *mut jvmtiEnv, data: *const ::std::os::raw::c_void) -> jvmtiError,
2552    >,
2553    pub AddToBootstrapClassLoaderSearch: ::std::option::Option<
2554        unsafe extern "C" fn(
2555            env: *mut jvmtiEnv,
2556            segment: *const ::std::os::raw::c_char,
2557        ) -> jvmtiError,
2558    >,
2559    pub SetVerboseFlag: ::std::option::Option<
2560        unsafe extern "C" fn(
2561            env: *mut jvmtiEnv,
2562            flag: jvmtiVerboseFlag,
2563            value: jboolean,
2564        ) -> jvmtiError,
2565    >,
2566    pub AddToSystemClassLoaderSearch: ::std::option::Option<
2567        unsafe extern "C" fn(
2568            env: *mut jvmtiEnv,
2569            segment: *const ::std::os::raw::c_char,
2570        ) -> jvmtiError,
2571    >,
2572    pub RetransformClasses: ::std::option::Option<
2573        unsafe extern "C" fn(
2574            env: *mut jvmtiEnv,
2575            class_count: jint,
2576            classes: *const jclass,
2577        ) -> jvmtiError,
2578    >,
2579    pub GetOwnedMonitorStackDepthInfo: ::std::option::Option<
2580        unsafe extern "C" fn(
2581            env: *mut jvmtiEnv,
2582            thread: jthread,
2583            monitor_info_count_ptr: *mut jint,
2584            monitor_info_ptr: *mut *mut jvmtiMonitorStackDepthInfo,
2585        ) -> jvmtiError,
2586    >,
2587    pub GetObjectSize: ::std::option::Option<
2588        unsafe extern "C" fn(
2589            env: *mut jvmtiEnv,
2590            object: jobject,
2591            size_ptr: *mut jlong,
2592        ) -> jvmtiError,
2593    >,
2594    pub GetLocalInstance: ::std::option::Option<
2595        unsafe extern "C" fn(
2596            env: *mut jvmtiEnv,
2597            thread: jthread,
2598            depth: jint,
2599            value_ptr: *mut jobject,
2600        ) -> jvmtiError,
2601    >,
2602    pub SetHeapSamplingInterval: ::std::option::Option<
2603        unsafe extern "C" fn(env: *mut jvmtiEnv, sampling_interval: jint) -> jvmtiError,
2604    >,
2605}
2606pub type jvmtiInterface_1 = jvmtiInterface_1_;
2607#[repr(C)]
2608#[derive(Debug, Copy, Clone)]
2609pub struct _jvmtiEnv {
2610    pub functions: *const jvmtiInterface_1_,
2611}