f06a83c0b2
libjava/ 2007-08-04 Matthias Klose <doko@ubuntu.com> Import GNU Classpath (libgcj-import-20070727). * Regenerate class and header files. * Regenerate auto* files. * include/jvm.h: * jni-libjvm.cc (Jv_JNI_InvokeFunctions): Rename type. * jni.cc (_Jv_JNIFunctions, _Jv_JNI_InvokeFunctions): Likewise. * jni.cc (_Jv_JNI_CallAnyMethodA, _Jv_JNI_CallAnyVoidMethodA, _Jv_JNI_CallMethodA, _Jv_JNI_CallVoidMethodA, _Jv_JNI_CallStaticMethodA, _Jv_JNI_CallStaticVoidMethodA, _Jv_JNI_NewObjectA, _Jv_JNI_SetPrimitiveArrayRegion): Constify jvalue parameter. * java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise. * java/lang/VMFloat.java (toString, parseFloat): New. * gnu/awt/xlib/XToolkit.java (setAlwaysOnTop, isModalityTypeSupported, isModalExclusionTypeSupported): New (stub only). * gnu/awt/xlib/XCanvasPeer.java (requestFocus): Likewise. * gnu/awt/xlib/XFramePeer.java (updateMinimumSize, updateIconImages, updateFocusableWindowState, setModalBlocked, getBoundsPrivate, setAlwaysOnTop): Likewise. * gnu/awt/xlib/XFontPeer.java (canDisplay): Update signature. * scripts/makemake.tcl: Ignore gnu/javax/sound/sampled/gstreamer, ignore javax.sound.sampled.spi.MixerProvider, ignore .in files. * HACKING: Mention --enable-gstreamer-peer, removal of generated files. libjava/classpath/ 2007-08-04 Matthias Klose <doko@ubuntu.com> * java/util/EnumMap.java (clone): Add cast. From-SVN: r127204
1820 lines
56 KiB
C++
1820 lines
56 KiB
C++
/* jvmti.h - Java Virtual Machine Tool Interface
|
|
Copyright (C) 2006 Free Software Foundation
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
/* Note: this file must be compilable by the C compiler (for now,
|
|
assuming GNU C is ok). This means you must never use `//'
|
|
comments, and all C++-specific code must be conditional on
|
|
__cplusplus. */
|
|
|
|
#ifndef _CLASSPATH_JVMTI_H
|
|
#define _CLASSPATH_JVMTI_H
|
|
#include <jni.h>
|
|
|
|
#include "jvmti_md.h"
|
|
|
|
/* The VM might define JVMTI base types */
|
|
#ifndef _CLASSPATH_VM_JVMTI_TYPES_DEFINED
|
|
|
|
typedef jobject jthread;
|
|
typedef jobject jthreadGroup;
|
|
typedef jlong jlocation;
|
|
typedef struct _Jv_rawMonitorID *jrawMonitorID;
|
|
|
|
#endif /* !_CLASSPATH_VM_JVMTI_TYPES_DEFINED */
|
|
|
|
/* JVMTI Version */
|
|
#define JVMTI_VERSION_1_0 0x30010000
|
|
#define JVMTI_VERSION (JVMTI_VERSION_1_0 + 38) /* Spec version is 1.0.38 */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
/* These functions might be defined in libraries which we load; the
|
|
JVMTI implementation calls them at the appropriate times. */
|
|
extern JNIEXPORT jint JNICALL Agent_OnLoad (JavaVM *vm, char *options,
|
|
void *reserved);
|
|
extern JNIEXPORT void JNICALL Agent_OnUnload (JavaVM *vm);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/* Forward declarations */
|
|
typedef struct _jvmtiAddrLocationMap jvmtiAddrLocationMap;
|
|
#ifdef __cplusplus
|
|
typedef struct _Jv_JVMTIEnv jvmtiEnv;
|
|
#else
|
|
typedef const struct _Jv_jvmtiEnv *jvmtiEnv;
|
|
#endif
|
|
|
|
/*
|
|
* Error constants
|
|
*/
|
|
|
|
typedef enum
|
|
{
|
|
/* Universal Errors */
|
|
JVMTI_ERROR_NONE = 0,
|
|
JVMTI_ERROR_NULL_POINTER = 100,
|
|
JVMTI_ERROR_OUT_OF_MEMORY = 110,
|
|
JVMTI_ERROR_ACCESS_DENIED = 111,
|
|
JVMTI_ERROR_WRONG_PHASE = 112,
|
|
JVMTI_ERROR_INTERNAL = 113,
|
|
JVMTI_ERROR_UNATTACHED_THREAD = 115,
|
|
JVMTI_ERROR_INVALID_ENVIRONMENT = 116,
|
|
|
|
/* Function-specific Required Errors */
|
|
JVMTI_ERROR_INVALID_PRIORITY = 12,
|
|
JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13,
|
|
JVMTI_ERROR_THREAD_SUSPENDED = 14,
|
|
JVMTI_ERROR_THREAD_NOT_ALIVE = 15,
|
|
JVMTI_ERROR_CLASS_NOT_PREPARED = 22,
|
|
JVMTI_ERROR_NO_MORE_FRAMES = 31,
|
|
JVMTI_ERROR_OPAQUE_FRAME = 32,
|
|
JVMTI_ERROR_DUPLICATE = 40,
|
|
JVMTI_ERROR_NOT_FOUND = 41,
|
|
JVMTI_ERROR_NOT_MONITOR_OWNER = 51,
|
|
JVMTI_ERROR_INTERRUPT = 52,
|
|
JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
|
|
JVMTI_ERROR_NOT_AVAILABLE = 98,
|
|
JVMTI_ERROR_ABSENT_INFORMATION = 101,
|
|
JVMTI_ERROR_INVALID_EVENT_TYPE = 102,
|
|
JVMTI_ERROR_NATIVE_METHOD = 104,
|
|
|
|
/* Function-specific Agent Errors */
|
|
JVMTI_ERROR_INVALID_THREAD = 10,
|
|
JVMTI_ERROR_INVALID_THREAD_GROUP = 11,
|
|
JVMTI_ERROR_INVALID_OBJECT = 20,
|
|
JVMTI_ERROR_INVALID_CLASS = 21,
|
|
JVMTI_ERROR_INVALID_METHODID = 23,
|
|
JVMTI_ERROR_INVALID_LOCATION = 24,
|
|
JVMTI_ERROR_INVALID_FIELDID = 25,
|
|
JVMTI_ERROR_TYPE_MISMATCH = 34,
|
|
JVMTI_ERROR_INVALID_SLOT = 35,
|
|
JVMTI_ERROR_INVALID_MONITOR = 50,
|
|
JVMTI_ERROR_INVALID_CLASS_FORMAT = 60,
|
|
JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64,
|
|
JVMTI_ERROR_INVALID_TYPESTATE = 65,
|
|
JVMTI_ERROR_FAILS_VERIFICATION = 62,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67,
|
|
JVMTI_ERROR_UNSUPPORTED_VERSION = 68,
|
|
JVMTI_ERROR_NAMES_DONT_MATCH = 69,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70,
|
|
JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71,
|
|
JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99,
|
|
JVMTI_ERROR_ILLEGAL_ARGUMENT = 103
|
|
} jvmtiError;
|
|
|
|
/*
|
|
* Enumeration Definitions
|
|
*/
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_DISABLE = 0,
|
|
JVMTI_ENABLE = 1
|
|
} jvmtiEventMode;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_HEAP_OBJECT_TAGGED = 1,
|
|
JVMTI_HEAP_OBJECT_UNTAGGED = 2,
|
|
JVMTI_HEAP_OBJECT_EITHER = 3
|
|
} jvmtiHeapObjectFilter;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_HEAP_ROOT_JNI_GLOBAL = 1,
|
|
JVMTI_HEAP_ROOT_SYSTEM_CLASS = 2,
|
|
JVMTI_HEAP_ROOT_MONITOR = 3,
|
|
JVMTI_HEAP_ROOT_STACK_LOCAL = 4,
|
|
JVMTI_HEAP_ROOT_JNI_LOCAL = 5,
|
|
JVMTI_HEAP_ROOT_THREAD = 6,
|
|
JVMTI_HEAP_ROOT_OTHER = 7
|
|
} jvmtiHeapRootKind;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_ITERATION_ABORT = 0,
|
|
JVMTI_ITERATION_CONTINUE = 1,
|
|
JVMTI_ITERATION_IGNORE = 2
|
|
} jvmtiIterationControl;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_JLOCATION_OTHER = 0,
|
|
JVMTI_JLOCATION_JVMBCI = 1,
|
|
JVMTI_JLOCATION_MACHINEPC = 2
|
|
} jvmtiJlocationFormat;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_REFERENCE_CLASS = 1,
|
|
JVMTI_REFERENCE_FIELD = 2,
|
|
JVMTI_REFERENCE_ARRAY_ELEMENT = 3,
|
|
JVMTI_REFERENCE_CLASS_LOADER = 4,
|
|
JVMTI_REFERENCE_SIGNERS = 5,
|
|
JVMTI_REFERENCE_PROTECTION_DOMAIN = 6,
|
|
JVMTI_REFERENCE_INTERFACE = 7,
|
|
JVMTI_REFERENCE_STATIC_FIELD = 8,
|
|
JVMTI_REFERENCE_CONSTANT_POOL = 9
|
|
} jvmtiObjectReferenceKind;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_KIND_IN = 91,
|
|
JVMTI_KIND_IN_PTR = 92,
|
|
JVMTI_KIND_IN_BUF = 93,
|
|
JVMTI_KIND_ALLOC_BUF = 94,
|
|
JVMTI_KIND_ALLOC_ALLOC_BUF = 95,
|
|
JVMTI_KIND_OUT = 96,
|
|
JVMTI_KIND_OUT_BUF = 97
|
|
} jvmtiParamKind;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_TYPE_JBYTE = 101,
|
|
JVMTI_TYPE_JCHAR = 102,
|
|
JVMTI_TYPE_JSHORT = 103,
|
|
JVMTI_TYPE_JINT = 104,
|
|
JVMTI_TYPE_JLONG = 105,
|
|
JVMTI_TYPE_JFLOAT = 106,
|
|
JVMTI_TYPE_JDOUBLE = 107,
|
|
JVMTI_TYPE_JBOOLEAN = 108,
|
|
JVMTI_TYPE_JOBJECT = 109,
|
|
JVMTI_TYPE_JTHREAD = 110,
|
|
JVMTI_TYPE_JCLASS = 111,
|
|
JVMTI_TYPE_JVALUE = 112,
|
|
JVMTI_TYPE_JFIELDID = 113,
|
|
JVMTI_TYPE_JMETHODID = 114,
|
|
JVMTI_TYPE_CCHAR = 115,
|
|
JVMTI_TYPE_CVOID = 116,
|
|
JVMTI_TYPE_JNIENV = 117
|
|
} jvmtiParamTypes;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_PHASE_ONLOAD = 1,
|
|
JVMTI_PHASE_PRIMORDIAL = 2,
|
|
JVMTI_PHASE_LIVE = 4,
|
|
JVMTI_PHASE_START = 6,
|
|
JVMTI_PHASE_DEAD = 8
|
|
} jvmtiPhase;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_TIMER_USER_CPU = 30,
|
|
JVMTI_TIMER_TOTAL_CPU = 31,
|
|
JVMTI_TIMER_ELAPSED = 32
|
|
} jvmtiTimerKind;
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_VERBOSE_OTHER = 0,
|
|
JVMTI_VERBOSE_GC = 1,
|
|
JVMTI_VERBOSE_CLASS = 2,
|
|
JVMTI_VERBOSE_JNI = 4
|
|
} jvmtiVerboseFlag;
|
|
|
|
/* Version information */
|
|
#define JVMTI_VERSION_INTERFACE_JNI 0x00000000
|
|
#define JVMTI_VERSION_INTERFACE_JVMTI 0x30000000
|
|
#define JVMTI_VERSION_MASK_INTERFACE_TYPE 0x70000000
|
|
#define JVMTI_VERSION_MASK_MAJOR 0x0FFF0000
|
|
#define JVMTI_VERSION_MASK_MINOR 0x0000FF00
|
|
#define JVMTI_VERSION_MASK_MICRO 0x000000FF
|
|
#define JVMTI_VERSION_SHIFT_MAJOR 16
|
|
#define JVMTI_VERSION_SHIFT_MINOR 8
|
|
#define JVMTI_VERSION_SHIFT_MICRO 0
|
|
|
|
/*
|
|
* Events and event callbacks
|
|
*/
|
|
|
|
typedef enum
|
|
{
|
|
JVMTI_EVENT_VM_INIT = 50,
|
|
JVMTI_EVENT_VM_DEATH = 51,
|
|
JVMTI_EVENT_THREAD_START = 52,
|
|
JVMTI_EVENT_THREAD_END = 53,
|
|
JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54,
|
|
JVMTI_EVENT_CLASS_LOAD = 55,
|
|
JVMTI_EVENT_CLASS_PREPARE = 56,
|
|
JVMTI_EVENT_VM_START = 57,
|
|
JVMTI_EVENT_EXCEPTION = 58,
|
|
JVMTI_EVENT_EXCEPTION_CATCH = 59,
|
|
JVMTI_EVENT_SINGLE_STEP = 60,
|
|
JVMTI_EVENT_FRAME_POP = 61,
|
|
JVMTI_EVENT_BREAKPOINT = 62,
|
|
JVMTI_EVENT_FIELD_ACCESS = 63,
|
|
JVMTI_EVENT_FIELD_MODIFICATION = 64,
|
|
JVMTI_EVENT_METHOD_ENTRY = 65,
|
|
JVMTI_EVENT_METHOD_EXIT = 66,
|
|
JVMTI_EVENT_NATIVE_METHOD_BIND = 67,
|
|
JVMTI_EVENT_COMPILED_METHOD_LOAD = 68,
|
|
JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69,
|
|
JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70,
|
|
JVMTI_EVENT_DATA_DUMP_REQUEST = 71,
|
|
JVMTI_EVENT_MONITOR_WAIT = 73,
|
|
JVMTI_EVENT_MONITOR_WAITED = 74,
|
|
JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75,
|
|
JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76,
|
|
JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
|
|
JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
|
|
JVMTI_EVENT_OBJECT_FREE = 83,
|
|
JVMTI_EVENT_VM_OBJECT_ALLOC = 84
|
|
} jvmtiEvent;
|
|
|
|
typedef void *jvmtiEventReserved;
|
|
|
|
typedef void (JNICALL *jvmtiEventSingleStep)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location);
|
|
|
|
typedef void (JNICALL *jvmtiEventBreakpoint)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location);
|
|
|
|
typedef void (JNICALL *jvmtiEventFieldAccess)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location, jclass field_klass, jobject object, jfieldID field);
|
|
|
|
typedef void (JNICALL *jvmtiEventFieldModification)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location, jclass field_klass, jobject object, jfieldID field,
|
|
char signature_type, jvalue new_value);
|
|
|
|
typedef void (JNICALL *jvmtiEventFramePop)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jboolean was_popped_by_exception);
|
|
|
|
typedef void (JNICALL *jvmtiEventMethodEntry)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method);
|
|
|
|
typedef void (JNICALL *jvmtiEventMethodExit)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jboolean was_popped_by_exception, jvalue return_value);
|
|
|
|
typedef void (JNICALL *jvmtiEventNativeMethodBind)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
void *address, void **new_address_ptr);
|
|
|
|
typedef void (JNICALL *jvmtiEventException)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location, jobject exception, jmethodID catch_method,
|
|
jlocation catch_location);
|
|
|
|
typedef void (JNICALL *jvmtiEventExceptionCatch)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jmethodID method,
|
|
jlocation location, jobject exception);
|
|
|
|
typedef void (JNICALL *jvmtiEventThreadStart)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread);
|
|
|
|
typedef void (JNICALL *jvmtiEventThreadEnd)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread);
|
|
|
|
typedef void (JNICALL *jvmtiEventClassLoad)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jclass klass);
|
|
|
|
typedef void (JNICALL *jvmtiEventClassPrepare)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thraed, jclass klass);
|
|
|
|
typedef void (JNICALL *jvmtiEventClassFileLoadHook)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jclass class_being_redefined,
|
|
jobject loader, const char *name, jobject protection_domain,
|
|
jint class_data_len, const unsigned char *class_data,
|
|
jint *new_class_data_len, unsigned char **new_class_data);
|
|
|
|
typedef void (JNICALL *jvmtiEventVMStart)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env);
|
|
|
|
typedef void (JNICALL *jvmtiEventVMInit)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread);
|
|
|
|
typedef void (JNICALL *jvmtiEventVMDeath)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env);
|
|
|
|
typedef void (JNICALL *jvmtiEventCompiledMethodLoad)
|
|
(jvmtiEnv *jvmti_env, jmethodID method, jint code_size,
|
|
const void *code_addr, jint map_length, const jvmtiAddrLocationMap *map,
|
|
const void *compile_info);
|
|
|
|
typedef void (JNICALL *jvmtiEventCompiledMethodUnload)
|
|
(jvmtiEnv *jvmti_env, jmethodID method, const void *code_addr);
|
|
|
|
typedef void (JNICALL *jvmtiEventDynamicCodeGenerated)
|
|
(jvmtiEnv *jvmti_env, const char *name, const void *address, jint length);
|
|
|
|
typedef void (JNICALL *jvmtiEventDataDumpRequest)
|
|
(jvmtiEnv *jvmti_env);
|
|
|
|
typedef void (JNICALL *jvmtiEventMonitorContendedEnter)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object);
|
|
|
|
typedef void (JNICALL *jvmtiEventMonitorContendedEntered)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object);
|
|
|
|
typedef void (JNICALL *jvmtiEventMonitorWait)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object,
|
|
jlong timeout);
|
|
|
|
typedef void (JNICALL *jvmtiEventMonitorWaited)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object,
|
|
jboolean timed_out);
|
|
|
|
typedef void (JNICALL *jvmtiEventVMObjectAlloc)
|
|
(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jobject object,
|
|
jclass object_klass, jlong size);
|
|
|
|
typedef void (JNICALL *jvmtiEventObjectFree)
|
|
(jvmtiEnv *jvmti_env, jlong tag);
|
|
|
|
typedef void (JNICALL *jvmtiEventGarbageCollectionStart)
|
|
(jvmtiEnv *jvmti_env);
|
|
|
|
typedef void (JNICALL *jvmtiEventGarbageCollectionFinish)
|
|
(jvmtiEnv *jvmti_env);
|
|
|
|
typedef struct
|
|
{
|
|
jvmtiEventVMInit VMInit;
|
|
jvmtiEventVMDeath VMDeath;
|
|
jvmtiEventThreadStart ThreadStart;
|
|
jvmtiEventThreadEnd ThreadEnd;
|
|
jvmtiEventClassFileLoadHook ClassFileLoadHook;
|
|
jvmtiEventClassLoad ClassLoad;
|
|
jvmtiEventClassPrepare ClassPrepare;
|
|
jvmtiEventVMStart VMStart;
|
|
jvmtiEventException Exception;
|
|
jvmtiEventExceptionCatch ExceptionCatch;
|
|
jvmtiEventSingleStep SingleStep;
|
|
jvmtiEventFramePop FramePop;
|
|
jvmtiEventBreakpoint Breakpoint;
|
|
jvmtiEventFieldAccess FieldAccess;
|
|
jvmtiEventFieldModification FieldModification;
|
|
jvmtiEventMethodEntry MethodEntry;
|
|
jvmtiEventMethodExit MethodExit;
|
|
jvmtiEventNativeMethodBind NativeMethodBind;
|
|
jvmtiEventCompiledMethodLoad CompiledMethodLoad;
|
|
jvmtiEventCompiledMethodUnload CompiledMethodUnload;
|
|
jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
|
|
jvmtiEventDataDumpRequest DataDumpRequest;
|
|
jvmtiEventReserved reserved72;
|
|
jvmtiEventMonitorWait MonitorWait;
|
|
jvmtiEventMonitorWaited MonitorWaited;
|
|
jvmtiEventMonitorContendedEnter MonitorContendedEnter;
|
|
jvmtiEventMonitorContendedEntered MonitorContendedEntered;
|
|
jvmtiEventReserved reserved77;
|
|
jvmtiEventReserved reserved78;
|
|
jvmtiEventReserved reserved79;
|
|
jvmtiEventReserved reserved80;
|
|
jvmtiEventGarbageCollectionStart GarbageCollectionStart;
|
|
jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
|
|
jvmtiEventObjectFree ObjectFree;
|
|
jvmtiEventVMObjectAlloc VMObjectAlloc;
|
|
} jvmtiEventCallbacks;
|
|
|
|
/*
|
|
* Function and Structure Type Definitions
|
|
*/
|
|
|
|
struct _jvmtiAddrLocationMap
|
|
{
|
|
const void *start_address;
|
|
jlocation location;
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int can_tag_objects : 1;
|
|
unsigned int can_generate_field_modification_events : 1;
|
|
unsigned int can_generate_field_access_events : 1;
|
|
unsigned int can_get_bytecodes : 1;
|
|
unsigned int can_get_synthetic_attribute : 1;
|
|
unsigned int can_get_owned_monitor_info : 1;
|
|
unsigned int can_get_current_contended_monitor : 1;
|
|
unsigned int can_get_monitor_info : 1;
|
|
unsigned int can_pop_frame : 1;
|
|
unsigned int can_redefine_classes : 1;
|
|
unsigned int can_signal_thread : 1;
|
|
unsigned int can_get_source_file_name : 1;
|
|
unsigned int can_get_line_numbers : 1;
|
|
unsigned int can_get_source_debug_extension : 1;
|
|
unsigned int can_access_local_variables : 1;
|
|
unsigned int can_maintain_original_method_order : 1;
|
|
unsigned int can_generate_single_step_events : 1;
|
|
unsigned int can_generate_exception_events : 1;
|
|
unsigned int can_generate_frame_pop_events : 1;
|
|
unsigned int can_generate_breakpoint_events : 1;
|
|
unsigned int can_suspend : 1;
|
|
unsigned int can_redefine_any_class : 1;
|
|
unsigned int can_get_current_thread_cpu_time : 1;
|
|
unsigned int can_get_thread_cpu_time : 1;
|
|
unsigned int can_generate_method_entry_events : 1;
|
|
unsigned int can_generate_method_exit_events : 1;
|
|
unsigned int can_generate_all_class_hook_events : 1;
|
|
unsigned int can_generate_compiled_method_load_events : 1;
|
|
unsigned int can_generate_monitor_events : 1;
|
|
unsigned int can_generate_vm_object_alloc_events : 1;
|
|
unsigned int can_generate_native_method_bind_events : 1;
|
|
unsigned int can_generate_garbage_collection_events : 1;
|
|
unsigned int can_generate_object_free_events : 1;
|
|
unsigned int : 15;
|
|
unsigned int : 16;
|
|
unsigned int : 16;
|
|
unsigned int : 16;
|
|
unsigned int : 16;
|
|
unsigned int : 16;
|
|
} jvmtiCapabilities;
|
|
|
|
typedef struct
|
|
{
|
|
jclass klass;
|
|
jint class_byte_count;
|
|
const unsigned char *class_bytes;
|
|
} jvmtiClassDefinition;
|
|
|
|
typedef struct
|
|
{
|
|
char *name;
|
|
jvmtiParamKind kind;
|
|
jvmtiParamTypes base_type;
|
|
jboolean null_ok;
|
|
} jvmtiParamInfo;
|
|
|
|
typedef struct
|
|
{
|
|
jint extension_event_index;
|
|
char *id;
|
|
char *short_description;
|
|
jint param_count;
|
|
jvmtiParamInfo* params;
|
|
} jvmtiExtensionEventInfo;
|
|
|
|
typedef jvmtiError (JNICALL *jvmtiExtensionFunction)
|
|
(jvmtiEnv *jvmti_enf, ...);
|
|
|
|
typedef struct
|
|
{
|
|
jvmtiExtensionFunction func;
|
|
char *id;
|
|
char *short_description;
|
|
jint param_count;
|
|
jvmtiParamInfo *params;
|
|
jint error_count;
|
|
jvmtiError *errors;
|
|
} jvmtiExtensionFunctionInfo;
|
|
|
|
typedef struct
|
|
{
|
|
jmethodID method;
|
|
jlocation location;
|
|
} jvmtiFrameInfo;
|
|
|
|
typedef struct
|
|
{
|
|
jlocation start_location;
|
|
jint line_number;
|
|
} jvmtiLineNumberEntry;
|
|
|
|
typedef struct
|
|
{
|
|
jlocation start_location;
|
|
jint length;
|
|
char *name;
|
|
char *signature;
|
|
char *generic_signature;
|
|
jint slot;
|
|
} jvmtiLocalVariableEntry;
|
|
|
|
typedef struct
|
|
{
|
|
jthread owner;
|
|
jint entry_count;
|
|
jint waiter_count;
|
|
jthread *waiters;
|
|
jint notify_waiter_count;
|
|
jthread *notify_waiters;
|
|
} jvmtiMonitorUsage;
|
|
|
|
typedef struct
|
|
{
|
|
jthread thread;
|
|
jint state;
|
|
jvmtiFrameInfo *frame_buffer;
|
|
jint frame_count;
|
|
} jvmtiStackInfo;
|
|
|
|
typedef struct
|
|
{
|
|
jthreadGroup parent;
|
|
char *name;
|
|
jint max_priority;
|
|
jboolean is_daemon;
|
|
} jvmtiThreadGroupInfo;
|
|
|
|
typedef struct
|
|
{
|
|
char *name;
|
|
jint priority;
|
|
jboolean is_daemon;
|
|
jthreadGroup thread_group;
|
|
jobject context_class_loader;
|
|
} jvmtiThreadInfo;
|
|
|
|
typedef struct
|
|
{
|
|
jlong max_value;
|
|
jboolean may_skip_forward;
|
|
jboolean may_skip_backward;
|
|
jvmtiTimerKind kind;
|
|
jlong reserved1;
|
|
jlong reserved2;
|
|
} jvmtiTimerInfo;
|
|
|
|
typedef void (JNICALL *jvmtiExtensionEvent)
|
|
(jvmtiEnv *jvmti_env, ...);
|
|
|
|
typedef jvmtiIterationControl (JNICALL *jvmtiHeapObjectCallback)
|
|
(jlong class_tag, jlong size, jlong *tag_ptr, void *user_data);
|
|
|
|
typedef jvmtiIterationControl (JNICALL *jvmtiHeapRootCallback)
|
|
(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong *tag_ptr,
|
|
void *user_data);
|
|
|
|
typedef jvmtiIterationControl (JNICALL *jvmtiObjectReferenceCallback)
|
|
(jvmtiObjectReferenceKind reference_kind, jlong class_tag, jlong size,
|
|
jlong *tag_ptr, jlong referrer_tag, jint referrer_index, void *user_data);
|
|
|
|
typedef jvmtiIterationControl (JNICALL *jvmtiStackReferenceCallback)
|
|
(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size, jlong *tag_ptr,
|
|
jlong thread_tag, jint depth, jmethodID method, jint slot, void *user_data);
|
|
|
|
typedef void (JNICALL *jvmtiStartFunction)
|
|
(jvmtiEnv *env, JNIEnv *jni_env, void *arg);
|
|
|
|
/*
|
|
* JVM Tool Interface Base Types
|
|
*/
|
|
typedef struct JNINativeInterface_ jniNativeInterface;
|
|
|
|
struct _Jv_jvmtiEnv
|
|
{
|
|
void *reserved1;
|
|
|
|
jvmtiError (JNICALL *SetEventNotificationMode) (jvmtiEnv *env,
|
|
jvmtiEventMode mode,
|
|
jvmtiEvent event_type,
|
|
jthread event_thread, ...);
|
|
void *reserved3;
|
|
|
|
jvmtiError (JNICALL *GetAllThreads) (jvmtiEnv *env,
|
|
jint *threads_count_ptr,
|
|
jthread **threads_ptr);
|
|
|
|
jvmtiError (JNICALL *SuspendThread) (jvmtiEnv *env,
|
|
jthread thread);
|
|
|
|
jvmtiError (JNICALL *ResumeThread) (jvmtiEnv *env,
|
|
jthread thread);
|
|
|
|
jvmtiError (JNICALL *StopThread) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jobject exception);
|
|
|
|
jvmtiError (JNICALL *InterruptThread) (jvmtiEnv *env,
|
|
jthread thread);
|
|
|
|
jvmtiError (JNICALL *GetThreadInfo) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jvmtiThreadInfo *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetOwnedMonitorInfo) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint *owned_monitor_count_ptr,
|
|
jobject **owned_monitors_ptr);
|
|
|
|
jvmtiError (JNICALL *GetCurrentContendedMonitor) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jobject *monitor_ptr);
|
|
|
|
jvmtiError (JNICALL *RunAgentThread) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jvmtiStartFunction proc,
|
|
const void *arg,
|
|
jint priority);
|
|
|
|
jvmtiError (JNICALL *GetTopThreadGroups) (jvmtiEnv *env,
|
|
jint *group_count_ptr,
|
|
jthreadGroup **groups_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadGroupInfo) (jvmtiEnv *env,
|
|
jthreadGroup group,
|
|
jvmtiThreadGroupInfo *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadGroupChildren) (jvmtiEnv *env,
|
|
jthreadGroup group,
|
|
jint *thread_count_ptr,
|
|
jthread **threads_ptr,
|
|
jint *group_count_ptr,
|
|
jthreadGroup **groups_ptr);
|
|
jvmtiError (JNICALL *GetFrameCount) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint *count_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadState) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint *thread_state_ptr);
|
|
|
|
void *reserved18;
|
|
|
|
jvmtiError (JNICALL *GetFrameLocation) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jmethodID *method_ptr,
|
|
jlocation *location_ptr);
|
|
|
|
jvmtiError (JNICALL *NotifyPopFrame) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth);
|
|
|
|
jvmtiError (JNICALL *GetLocalObject) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jobject *value_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLocalInt) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jint *value_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLocalLong) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jlong *value_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLocalFloat) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jfloat *value_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLocalDouble) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jdouble *value_ptr);
|
|
|
|
jvmtiError (JNICALL *SetLocalObject) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jobject value);
|
|
|
|
jvmtiError (JNICALL *SetLocalInt) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jint value);
|
|
|
|
jvmtiError (JNICALL *SetLocalLong) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jlong value);
|
|
|
|
jvmtiError (JNICALL *SetLocalFloat) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jfloat value);
|
|
|
|
jvmtiError (JNICALL *SetLocalDouble) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint depth,
|
|
jint slot,
|
|
jdouble value);
|
|
|
|
jvmtiError (JNICALL *CreateRawMonitor) (jvmtiEnv *env,
|
|
const char *name,
|
|
jrawMonitorID *monitor_ptr);
|
|
|
|
jvmtiError (JNICALL *DestroyRawMonitor) (jvmtiEnv *env,
|
|
jrawMonitorID monitor);
|
|
|
|
jvmtiError (JNICALL *RawMonitorEnter) (jvmtiEnv *env,
|
|
jrawMonitorID monitor);
|
|
|
|
jvmtiError (JNICALL *RawMonitorExit) (jvmtiEnv *env,
|
|
jrawMonitorID monitor);
|
|
|
|
jvmtiError (JNICALL *RawMonitorWait) (jvmtiEnv *env,
|
|
jrawMonitorID monitor,
|
|
jlong millis);
|
|
|
|
jvmtiError (JNICALL *RawMonitorNotify) (jvmtiEnv *env,
|
|
jrawMonitorID monitor);
|
|
|
|
jvmtiError (JNICALL *RawMonitorNotifyAll) (jvmtiEnv *env,
|
|
jrawMonitorID monitor);
|
|
|
|
jvmtiError (JNICALL *SetBreakpoint) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jlocation location);
|
|
|
|
jvmtiError (JNICALL *ClearBreakpoint) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jlocation location);
|
|
|
|
void *reserved40;
|
|
|
|
jvmtiError (JNICALL *SetFieldAccessWatch) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field);
|
|
|
|
jvmtiError (JNICALL *ClearFieldAccessWatch) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field);
|
|
|
|
jvmtiError (JNICALL *SetFieldModificationWatch) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field);
|
|
|
|
jvmtiError (JNICALL *ClearFieldModificationWatch) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field);
|
|
|
|
void *reserved45;
|
|
|
|
jvmtiError (JNICALL *Allocate) (jvmtiEnv *env,
|
|
jlong size,
|
|
unsigned char **mem_ptr);
|
|
|
|
jvmtiError (JNICALL *Deallocate) (jvmtiEnv *env,
|
|
unsigned char *mem);
|
|
|
|
jvmtiError (JNICALL *GetClassSignature) (jvmtiEnv *env,
|
|
jclass klass,
|
|
char **signature_ptr,
|
|
char **generic_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassStatus) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jint *status_ptr);
|
|
|
|
jvmtiError (JNICALL *GetSourceFileName) (jvmtiEnv *env,
|
|
jclass klass,
|
|
char **source_name_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassModifiers) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jint *modifiers_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassMethods) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jint *method_count_ptr,
|
|
jmethodID **methods_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassFields) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jint *field_count_ptr,
|
|
jfieldID **fields_ptr);
|
|
|
|
jvmtiError (JNICALL *GetImplementedInterfaces) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jint *interface_count_ptr,
|
|
jclass **interfaces_ptr);
|
|
|
|
jvmtiError (JNICALL *IsInterface) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jboolean *is_interface_ptr);
|
|
|
|
jvmtiError (JNICALL *IsArrayClass) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jboolean *is_array_class_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassLoader) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jobject *classloader_ptr);
|
|
|
|
jvmtiError (JNICALL *GetObjectHashCode) (jvmtiEnv *env,
|
|
jobject object,
|
|
jint *hash_code_ptr);
|
|
|
|
jvmtiError (JNICALL *GetObjectMonitorUsage) (jvmtiEnv *env,
|
|
jobject object,
|
|
jvmtiMonitorUsage *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetFieldName) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field,
|
|
char **name_ptr,
|
|
char **signature_ptr,
|
|
char **generic_ptr);
|
|
|
|
jvmtiError (JNICALL *GetFieldDeclaringClass) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field,
|
|
jclass *declaring_class_ptr);
|
|
|
|
jvmtiError (JNICALL *GetFieldModifiers) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field,
|
|
jint *modifiers_ptr);
|
|
|
|
jvmtiError (JNICALL *IsFieldSynthetic) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jfieldID field,
|
|
jboolean *is_synthetic_ptr);
|
|
|
|
jvmtiError (JNICALL *GetMethodName) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
char **name_ptr,
|
|
char **signature_ptr,
|
|
char **generic_ptr);
|
|
|
|
jvmtiError (JNICALL *GetMethodDeclaringClass) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jclass *declaring_class_ptr);
|
|
|
|
|
|
jvmtiError (JNICALL *GetMethodModifiers) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *modifiers_ptr);
|
|
|
|
void *reserved67;
|
|
|
|
jvmtiError (JNICALL *GetMaxLocals) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *max_ptr);
|
|
|
|
jvmtiError (JNICALL *GetArgumentsSize) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *size_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLineNumberTable) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *entry_count_ptr,
|
|
jvmtiLineNumberEntry **table_ptr);
|
|
|
|
jvmtiError (JNICALL *GetMethodLocation) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jlocation *start_location_ptr,
|
|
jlocation *end_location_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLocalVariableTable) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *entry_count_ptr,
|
|
jvmtiLocalVariableEntry **table_ptr);
|
|
|
|
void *reserved73;
|
|
|
|
void *reserved74;
|
|
|
|
jvmtiError (JNICALL *GetBytecodes) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jint *bytecode_count_ptr,
|
|
unsigned char **bytecodes_ptr);
|
|
|
|
jvmtiError (JNICALL *IsMethodNative) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jboolean *is_native_ptr);
|
|
|
|
jvmtiError (JNICALL *IsMethodSynthetic) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jboolean *is_synthetic_ptr);
|
|
|
|
jvmtiError (JNICALL *GetLoadedClasses) (jvmtiEnv *env,
|
|
jint *class_count_ptr,
|
|
jclass **classes_ptr);
|
|
|
|
jvmtiError (JNICALL *GetClassLoaderClasses) (jvmtiEnv *env,
|
|
jobject initiating_loader,
|
|
jint *class_count_ptr,
|
|
jclass **classes_ptr);
|
|
|
|
jvmtiError (JNICALL *PopFrame) (jvmtiEnv *env,
|
|
jthread thread);
|
|
|
|
void *reserved81;
|
|
|
|
void *reserved82;
|
|
|
|
void *reserved83;
|
|
|
|
void *reserved84;
|
|
|
|
void *reserved85;
|
|
|
|
void *reserved86;
|
|
|
|
jvmtiError (JNICALL *RedefineClasses) (jvmtiEnv *env,
|
|
jint class_count,
|
|
const jvmtiClassDefinition* class_definitions);
|
|
|
|
jvmtiError (JNICALL *GetVersionNumber) (jvmtiEnv *env,
|
|
jint *version_ptr);
|
|
|
|
jvmtiError (JNICALL *GetCapabilities) (jvmtiEnv *env,
|
|
jvmtiCapabilities *capabilities_ptr);
|
|
|
|
jvmtiError (JNICALL *GetSourceDebugExtension) (jvmtiEnv *env,
|
|
jclass klass,
|
|
char **source_debug_extension_ptr);
|
|
|
|
jvmtiError (JNICALL *IsMethodObsolete) (jvmtiEnv *env,
|
|
jmethodID method,
|
|
jboolean *is_obsolete_ptr);
|
|
|
|
jvmtiError (JNICALL *SuspendThreadList) (jvmtiEnv *env,
|
|
jint request_count,
|
|
const jthread *request_list,
|
|
jvmtiError *results);
|
|
|
|
jvmtiError (JNICALL *ResumeThreadList) (jvmtiEnv *env,
|
|
jint request_count,
|
|
const jthread *request_list,
|
|
jvmtiError *results);
|
|
|
|
void *reserved94;
|
|
|
|
void *reserved95;
|
|
|
|
void *reserved96;
|
|
|
|
void *reserved97;
|
|
|
|
void *reserved98;
|
|
|
|
void *reserved99;
|
|
|
|
jvmtiError (JNICALL *GetAllStackTraces) (jvmtiEnv *env,
|
|
jint max_frame_count,
|
|
jvmtiStackInfo **stack_info_ptr,
|
|
jint *thread_count_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadListStackTraces) (jvmtiEnv *env,
|
|
jint thread_count,
|
|
const jthread *thread_list,
|
|
jint max_frame_count,
|
|
jvmtiStackInfo **stack_info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadLocalStorage) (jvmtiEnv *env,
|
|
jthread thread,
|
|
void **data_ptr);
|
|
|
|
jvmtiError (JNICALL *SetThreadLocalStorage) (jvmtiEnv *env,
|
|
jthread thread,
|
|
const void *data);
|
|
|
|
jvmtiError (JNICALL *GetStackTrace) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jint start_depth,
|
|
jint max_frame_count,
|
|
jvmtiFrameInfo *frame_buffer,
|
|
jint *count_ptr);
|
|
|
|
void *reserved105;
|
|
|
|
jvmtiError (JNICALL *GetTag) (jvmtiEnv *env,
|
|
jobject object,
|
|
jlong *tag_ptr);
|
|
|
|
jvmtiError (JNICALL *SetTag) (jvmtiEnv *env,
|
|
jobject object,
|
|
jlong tag);
|
|
|
|
jvmtiError (JNICALL *ForceGarbageCollection) (jvmtiEnv *env);
|
|
|
|
jvmtiError (JNICALL *IterateOverObjectsReachableFromObject) (jvmtiEnv *env,
|
|
jobject object,
|
|
jvmtiObjectReferenceCallback object_reference_callback,
|
|
void *user_data);
|
|
|
|
jvmtiError (JNICALL *IterateOverReachableObjects) (jvmtiEnv *env,
|
|
jvmtiHeapRootCallback heap_root_callback,
|
|
jvmtiStackReferenceCallback stack_ref_callback,
|
|
jvmtiObjectReferenceCallback object_ref_callback,
|
|
void *user_data);
|
|
|
|
jvmtiError (JNICALL *IterateOverHeap) (jvmtiEnv *env,
|
|
jvmtiHeapObjectFilter object_filter,
|
|
jvmtiHeapObjectCallback heap_object_callback,
|
|
void *user_data);
|
|
|
|
jvmtiError (JNICALL *IterateOverInstanceOfClass) (jvmtiEnv *env,
|
|
jclass klass,
|
|
jvmtiHeapObjectFilter object_filter,
|
|
jvmtiHeapObjectCallback heap_object_callback,
|
|
void *user_data);
|
|
|
|
void *reserved113;
|
|
|
|
jvmtiError (JNICALL *GetObjectsWithTags) (jvmtiEnv *env,
|
|
jint tag_count,
|
|
const jlong *tags,
|
|
jint *count_ptr,
|
|
jobject **object_result_ptr,
|
|
jlong **tag_result_ptr);
|
|
|
|
void *reserved115;
|
|
|
|
void *reserved116;
|
|
|
|
void *reserved117;
|
|
|
|
void *reserved118;
|
|
|
|
void *reserved119;
|
|
|
|
jvmtiError (JNICALL *SetJNIFunctionTable) (jvmtiEnv *env,
|
|
const jniNativeInterface *function_table);
|
|
|
|
jvmtiError (JNICALL *GetJNIFunctionTable) (jvmtiEnv *env,
|
|
jniNativeInterface **function_table_ptr);
|
|
|
|
jvmtiError (JNICALL *SetEventCallbacks) (jvmtiEnv *env,
|
|
const jvmtiEventCallbacks *callbacks,
|
|
jint size_of_callbacks);
|
|
|
|
jvmtiError (JNICALL *GenerateEvents) (jvmtiEnv *env,
|
|
jvmtiEvent event_type);
|
|
|
|
jvmtiError (JNICALL *GetExtensionFunctions) (jvmtiEnv *env,
|
|
jint *extension_count_ptr,
|
|
jvmtiExtensionFunctionInfo **extensions);
|
|
|
|
jvmtiError (JNICALL *GetExtensionEvents) (jvmtiEnv *env,
|
|
jint *extension_count_ptr,
|
|
jvmtiExtensionEventInfo **extensions);
|
|
|
|
jvmtiError (JNICALL *SetExtensionEventCallback) (jvmtiEnv *env,
|
|
jint extension_event_index,
|
|
jvmtiExtensionEvent callback);
|
|
|
|
jvmtiError (JNICALL *DisposeEnvironment) (jvmtiEnv *env);
|
|
|
|
jvmtiError (JNICALL *GetErrorName) (jvmtiEnv *env,
|
|
jvmtiError error,
|
|
char **name_ptr);
|
|
|
|
jvmtiError (JNICALL *GetJLocationFormat) (jvmtiEnv *env,
|
|
jvmtiJlocationFormat *format_ptr);
|
|
|
|
jvmtiError (JNICALL *GetSystemProperties) (jvmtiEnv *env,
|
|
jint *count_ptr,
|
|
char ***property_ptr);
|
|
|
|
jvmtiError (JNICALL *GetSystemProperty) (jvmtiEnv *env,
|
|
const char *property,
|
|
char **value_ptr);
|
|
|
|
jvmtiError (JNICALL *SetSystemProperty) (jvmtiEnv *env,
|
|
const char *property,
|
|
const char *value);
|
|
|
|
jvmtiError (JNICALL *GetPhase) (jvmtiEnv *env,
|
|
jvmtiPhase *phase_ptr);
|
|
|
|
jvmtiError (JNICALL *GetCurrentThreadCpuTimerInfo) (jvmtiEnv *env,
|
|
jvmtiTimerInfo *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetCurrentThreadCpuTime) (jvmtiEnv *env,
|
|
jlong *nanos_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadCpuTimerInfo) (jvmtiEnv *env,
|
|
jvmtiTimerInfo *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetThreadCpuTime) (jvmtiEnv *env,
|
|
jthread thread,
|
|
jlong *nanos_ptr);
|
|
|
|
jvmtiError (JNICALL *GetTimerInfo) (jvmtiEnv *env,
|
|
jvmtiTimerInfo *info_ptr);
|
|
|
|
jvmtiError (JNICALL *GetTime) (jvmtiEnv *env,
|
|
jlong *nanos_ptr);
|
|
|
|
jvmtiError (JNICALL *GetPotentialCapabilities) (jvmtiEnv *env,
|
|
jvmtiCapabilities *capabilities_ptr);
|
|
|
|
void *reserved141;
|
|
|
|
jvmtiError (JNICALL *AddCapabilities) (jvmtiEnv *env,
|
|
const jvmtiCapabilities *capabilities_ptr);
|
|
|
|
jvmtiError (JNICALL *RelinquishCapabilities) (jvmtiEnv *env,
|
|
const jvmtiCapabilities *capabilities_ptr);
|
|
|
|
jvmtiError (JNICALL *GetAvailableProcessors) (jvmtiEnv *env,
|
|
jint *processor_count_ptr);
|
|
|
|
void *reserved145;
|
|
|
|
void *reserved146;
|
|
|
|
jvmtiError (JNICALL *GetEnvironmentLocalStorage) (jvmtiEnv *env,
|
|
void **data_ptr);
|
|
|
|
jvmtiError (JNICALL *SetEnvironmentLocalStorage) (jvmtiEnv *env,
|
|
const void *data);
|
|
|
|
jvmtiError (JNICALL *AddToBootstrapClassLoaderSearch) (jvmtiEnv *env,
|
|
const char *segment);
|
|
|
|
jvmtiError (JNICALL *SetVerboseFlag) (jvmtiEnv *env,
|
|
jvmtiVerboseFlag flag,
|
|
jboolean value);
|
|
|
|
void *reserved151;
|
|
|
|
void *reserved152;
|
|
|
|
void *reserved153;
|
|
|
|
jvmtiError (JNICALL *GetObjectSize) (jvmtiEnv *env,
|
|
jobject object,
|
|
jlong *size_ptr);
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
class _Jv_JVMTIEnv
|
|
{
|
|
public:
|
|
/* Method table */
|
|
struct _Jv_jvmtiEnv *p;
|
|
|
|
#ifdef _CLASSPATH_JVMTIENV_CONTENTS
|
|
_CLASSPATH_JVMTIENV_CONTENTS
|
|
#endif
|
|
|
|
jvmtiError SetEventNotificationMode (jvmtiEventMode mode,
|
|
jvmtiEvent event_type,
|
|
jthread event_thread, ...)
|
|
{
|
|
va_list args;
|
|
va_start (args, event_thread);
|
|
jvmtiError result = p->SetEventNotificationMode (this, mode, event_type,
|
|
event_thread, args);
|
|
va_end (args);
|
|
return result;
|
|
}
|
|
|
|
jvmtiError GetAllThreads (jint *threads_count_ptr, jthread **threads_ptr)
|
|
{ return p->GetAllThreads (this, threads_count_ptr, threads_ptr); }
|
|
|
|
jvmtiError SuspendThread (jthread thread)
|
|
{ return p->SuspendThread (this, thread); }
|
|
|
|
jvmtiError ResumeThread (jthread thread)
|
|
{ return p->ResumeThread (this, thread); }
|
|
|
|
jvmtiError StopThread (jthread thread, jobject exception)
|
|
{ return p->StopThread (this, thread, exception); }
|
|
|
|
jvmtiError InterruptThread (jthread thread)
|
|
{ return p->InterruptThread (this, thread); }
|
|
|
|
jvmtiError GetThreadInfo (jthread thread, jvmtiThreadInfo *info_ptr)
|
|
{ return p->GetThreadInfo (this, thread, info_ptr); }
|
|
|
|
jvmtiError GetOwnedMonitorInfo (jthread thread,
|
|
jint *owned_monitor_count_ptr,
|
|
jobject **owned_monitors_ptr)
|
|
{
|
|
return p->GetOwnedMonitorInfo (this, thread, owned_monitor_count_ptr,
|
|
owned_monitors_ptr);
|
|
}
|
|
|
|
jvmtiError GetCurrentContendedMonitor (jthread thread, jobject *monitor_ptr)
|
|
{ return p->GetCurrentContendedMonitor (this, thread, monitor_ptr); }
|
|
|
|
jvmtiError RunAgentThread (jthread thread, jvmtiStartFunction proc,
|
|
const void *arg, jint priority)
|
|
{ return p->RunAgentThread (this, thread, proc, arg, priority); }
|
|
|
|
jvmtiError GetTopThreadGroups (jint *group_count_ptr,
|
|
jthreadGroup **groups_ptr)
|
|
{ return p->GetTopThreadGroups (this, group_count_ptr, groups_ptr); }
|
|
|
|
jvmtiError GetThreadGroupInfo (jthreadGroup group,
|
|
jvmtiThreadGroupInfo *info_ptr)
|
|
{ return p->GetThreadGroupInfo (this, group, info_ptr); }
|
|
|
|
jvmtiError GetThreadGroupChildren (jthreadGroup group,
|
|
jint *thread_count_ptr,
|
|
jthread **threads_ptr,
|
|
jint *group_count_ptr,
|
|
jthreadGroup **groups_ptr)
|
|
{
|
|
return p->GetThreadGroupChildren (this, group, thread_count_ptr,
|
|
threads_ptr, group_count_ptr,
|
|
groups_ptr);
|
|
}
|
|
|
|
jvmtiError GetFrameCount (jthread thread, jint *count_ptr)
|
|
{ return p->GetFrameCount (this, thread, count_ptr); }
|
|
|
|
jvmtiError GetThreadState (jthread thread, jint *thread_state_ptr)
|
|
{ return p->GetThreadState (this, thread, thread_state_ptr); }
|
|
|
|
jvmtiError GetFrameLocation (jthread thread, jint depth,
|
|
jmethodID *method_ptr, jlocation *location_ptr)
|
|
{
|
|
return p->GetFrameLocation (this, thread, depth, method_ptr,
|
|
location_ptr);
|
|
}
|
|
|
|
jvmtiError NotifyPopFrame (jthread thread, jint depth)
|
|
{ return p->NotifyPopFrame (this, thread, depth); }
|
|
|
|
jvmtiError GetLocalObject (jthread thread, jint depth, jint slot,
|
|
jobject *value_ptr)
|
|
{ return p->GetLocalObject (this, thread, depth, slot, value_ptr); }
|
|
|
|
jvmtiError GetLocalInt (jthread thread, jint depth, jint slot,
|
|
jint *value_ptr)
|
|
{ return p->GetLocalInt (this, thread, depth, slot, value_ptr); }
|
|
|
|
jvmtiError GetLocalLong (jthread thread, jint depth, jint slot,
|
|
jlong *value_ptr)
|
|
{ return p->GetLocalLong (this, thread, depth, slot, value_ptr); }
|
|
|
|
jvmtiError GetLocalFloat (jthread thread, jint depth, jint slot,
|
|
jfloat *value_ptr)
|
|
{ return p->GetLocalFloat (this, thread, depth, slot, value_ptr); }
|
|
|
|
jvmtiError GetLocalDouble (jthread thread, jint depth, jint slot,
|
|
jdouble *value_ptr)
|
|
{ return p->GetLocalDouble (this, thread, depth, slot, value_ptr); }
|
|
|
|
jvmtiError SetLocalObject (jthread thread, jint depth, jint slot,
|
|
jobject value)
|
|
{ return p->SetLocalObject (this, thread, depth, slot, value); }
|
|
|
|
jvmtiError SetLocalInt (jthread thread, jint depth, jint slot,
|
|
jint value)
|
|
{ return p->SetLocalInt (this, thread, depth, slot, value); }
|
|
|
|
jvmtiError SetLocalLong (jthread thread, jint depth, jint slot,
|
|
jlong value)
|
|
{ return p->SetLocalLong (this, thread, depth, slot, value); }
|
|
|
|
jvmtiError SetLocalFloat (jthread thread, jint depth, jint slot,
|
|
jfloat value)
|
|
{ return p->SetLocalFloat (this, thread, depth, slot, value); }
|
|
|
|
jvmtiError SetLocalDouble (jthread thread, jint depth, jint slot,
|
|
jdouble value)
|
|
{ return p->SetLocalDouble (this, thread, depth, slot, value); }
|
|
|
|
jvmtiError CreateRawMonitor (const char *name, jrawMonitorID *monitor_ptr)
|
|
{ return p->CreateRawMonitor (this, name, monitor_ptr); }
|
|
|
|
jvmtiError DestroyRawMonitor (jrawMonitorID monitor)
|
|
{ return p->DestroyRawMonitor (this, monitor); }
|
|
|
|
jvmtiError RawMonitorEnter (jrawMonitorID monitor)
|
|
{ return p->RawMonitorEnter (this, monitor); }
|
|
|
|
jvmtiError RawMonitorExit (jrawMonitorID monitor)
|
|
{ return p->RawMonitorExit (this, monitor); }
|
|
|
|
jvmtiError RawMonitorWait (jrawMonitorID monitor, jlong millis)
|
|
{ return p->RawMonitorWait (this, monitor, millis); }
|
|
|
|
jvmtiError RawMonitorNotify (jrawMonitorID monitor)
|
|
{ return p->RawMonitorNotify (this, monitor); }
|
|
|
|
jvmtiError RawMonitorNotifyAll (jrawMonitorID monitor)
|
|
{ return p->RawMonitorNotifyAll (this, monitor); }
|
|
|
|
jvmtiError SetBreakpoint (jmethodID method, jlocation location)
|
|
{ return p->SetBreakpoint (this, method, location); }
|
|
|
|
jvmtiError ClearBreakpoint (jmethodID method, jlocation location)
|
|
{ return p->ClearBreakpoint (this, method, location); }
|
|
|
|
jvmtiError SetFieldAccessWatch (jclass klass, jfieldID field)
|
|
{ return p->SetFieldAccessWatch (this, klass, field); }
|
|
|
|
jvmtiError ClearFieldAccessWatch (jclass klass, jfieldID field)
|
|
{ return p->ClearFieldAccessWatch (this, klass, field); }
|
|
|
|
jvmtiError SetFieldModificationWatch (jclass klass, jfieldID field)
|
|
{ return p->SetFieldModificationWatch (this, klass, field); }
|
|
|
|
jvmtiError ClearFieldModificationWatch (jclass klass, jfieldID field)
|
|
{ return p->ClearFieldModificationWatch (this, klass, field); }
|
|
|
|
jvmtiError Allocate (jlong size, unsigned char **mem_ptr)
|
|
{ return p->Allocate (this, size, mem_ptr); }
|
|
|
|
jvmtiError Deallocate (unsigned char *mem)
|
|
{ return p->Deallocate (this, mem); }
|
|
|
|
jvmtiError GetClassSignature (jclass klass, char **signature_ptr,
|
|
char **generic_ptr)
|
|
{ return p->GetClassSignature (this, klass, signature_ptr, generic_ptr); }
|
|
|
|
jvmtiError GetClassStatus (jclass klass, jint *status_ptr)
|
|
{ return p->GetClassStatus (this, klass, status_ptr); }
|
|
|
|
jvmtiError GetSourceFileName (jclass klass, char **source_name_ptr)
|
|
{ return p->GetSourceFileName (this, klass, source_name_ptr); }
|
|
|
|
jvmtiError GetClassModifiers (jclass klass, jint *modifiers_ptr)
|
|
{ return p->GetClassModifiers (this, klass, modifiers_ptr); }
|
|
|
|
jvmtiError GetClassMethods (jclass klass, jint *method_count_ptr,
|
|
jmethodID **methods_ptr)
|
|
{ return p->GetClassMethods (this, klass, method_count_ptr, methods_ptr); }
|
|
|
|
jvmtiError GetClassFields (jclass klass, jint *field_count_ptr,
|
|
jfieldID **fields_ptr)
|
|
{ return p->GetClassFields (this, klass, field_count_ptr, fields_ptr); }
|
|
|
|
jvmtiError GetImplementedInterfaces (jclass klass,
|
|
jint *interface_count_ptr,
|
|
jclass **interfaces_ptr)
|
|
{
|
|
return p->GetImplementedInterfaces (this, klass, interface_count_ptr,
|
|
interfaces_ptr);
|
|
}
|
|
|
|
jvmtiError IsInterface (jclass klass, jboolean *is_interface_ptr)
|
|
{ return p->IsInterface (this, klass, is_interface_ptr); }
|
|
|
|
jvmtiError IsArrayClass (jclass klass, jboolean *is_array_class_ptr)
|
|
{ return p->IsArrayClass (this, klass, is_array_class_ptr); }
|
|
|
|
jvmtiError GetClassLoader (jclass klass, jobject *classloader_ptr)
|
|
{ return p->GetClassLoader (this, klass, classloader_ptr); }
|
|
|
|
jvmtiError GetObjectHashCode (jobject object, jint *hash_code_ptr)
|
|
{ return p->GetObjectHashCode (this, object, hash_code_ptr); }
|
|
|
|
jvmtiError GetObjectMonitorUsage (jobject object,
|
|
jvmtiMonitorUsage *info_ptr)
|
|
{ return p->GetObjectMonitorUsage (this, object, info_ptr); }
|
|
|
|
jvmtiError GetFieldName (jclass klass, jfieldID field, char **name_ptr,
|
|
char **signature_ptr, char **generic_ptr)
|
|
{
|
|
return p->GetFieldName (this, klass, field, name_ptr,
|
|
signature_ptr, generic_ptr);
|
|
}
|
|
|
|
jvmtiError GetFieldDeclaringClass (jclass klass, jfieldID field,
|
|
jclass *declaring_class_ptr)
|
|
{
|
|
return p->GetFieldDeclaringClass (this, klass, field,
|
|
declaring_class_ptr);
|
|
}
|
|
|
|
jvmtiError GetFieldModifiers (jclass klass, jfieldID field,
|
|
jint *modifiers_ptr)
|
|
{ return p->GetFieldModifiers (this, klass, field, modifiers_ptr); }
|
|
|
|
jvmtiError IsFieldSynthetic (jclass klass, jfieldID field,
|
|
jboolean *is_synthetic_ptr)
|
|
{ return p->IsFieldSynthetic (this, klass, field, is_synthetic_ptr); }
|
|
|
|
jvmtiError GetMethodName (jmethodID method, char **name_ptr,
|
|
char **signature_ptr, char **generic_ptr)
|
|
{
|
|
return p->GetMethodName (this, method, name_ptr, signature_ptr,
|
|
generic_ptr);
|
|
}
|
|
|
|
jvmtiError GetMethodDeclaringClass (jmethodID method,
|
|
jclass *declaring_class_ptr)
|
|
{ return p->GetMethodDeclaringClass (this, method, declaring_class_ptr); }
|
|
|
|
|
|
jvmtiError GetMethodModifiers (jmethodID method, jint *modifiers_ptr)
|
|
{ return p->GetMethodModifiers (this, method, modifiers_ptr); }
|
|
|
|
jvmtiError GetMaxLocals (jmethodID method, jint *max_ptr)
|
|
{ return p->GetMaxLocals (this, method, max_ptr); }
|
|
|
|
jvmtiError GetArgumentsSize (jmethodID method, jint *size_ptr)
|
|
{ return p->GetArgumentsSize (this, method, size_ptr); }
|
|
|
|
jvmtiError GetLineNumberTable (jmethodID method, jint *entry_count_ptr,
|
|
jvmtiLineNumberEntry **table_ptr)
|
|
{ return p->GetLineNumberTable (this, method, entry_count_ptr, table_ptr); }
|
|
|
|
jvmtiError GetMethodLocation (jmethodID method,
|
|
jlocation *start_location_ptr,
|
|
jlocation *end_location_ptr)
|
|
{
|
|
return p->GetMethodLocation (this, method, start_location_ptr,
|
|
end_location_ptr);
|
|
}
|
|
|
|
jvmtiError GetLocalVariableTable (jmethodID method, jint *entry_count_ptr,
|
|
jvmtiLocalVariableEntry **table_ptr)
|
|
{
|
|
return p->GetLocalVariableTable (this, method, entry_count_ptr,
|
|
table_ptr);
|
|
}
|
|
|
|
jvmtiError GetBytecodes (jmethodID method, jint *bytecode_count_ptr,
|
|
unsigned char **bytecodes_ptr)
|
|
{
|
|
return p->GetBytecodes (this, method, bytecode_count_ptr,
|
|
bytecodes_ptr);
|
|
}
|
|
|
|
jvmtiError IsMethodNative (jmethodID method, jboolean *is_native_ptr)
|
|
{ return p->IsMethodNative (this, method, is_native_ptr); }
|
|
|
|
jvmtiError IsMethodSynthetic (jmethodID method, jboolean *is_synthetic_ptr)
|
|
{ return p->IsMethodSynthetic (this, method, is_synthetic_ptr); }
|
|
|
|
jvmtiError GetLoadedClasses (jint *class_count_ptr, jclass **classes_ptr)
|
|
{ return p->GetLoadedClasses (this, class_count_ptr, classes_ptr); }
|
|
|
|
jvmtiError GetClassLoaderClasses (jobject initiating_loader,
|
|
jint *class_count_ptr,
|
|
jclass **classes_ptr)
|
|
{
|
|
return p->GetClassLoaderClasses (this, initiating_loader,
|
|
class_count_ptr, classes_ptr);
|
|
}
|
|
|
|
jvmtiError PopFrame (jthread thread)
|
|
{ return p->PopFrame (this, thread); }
|
|
|
|
jvmtiError RedefineClasses (jint class_count,
|
|
const jvmtiClassDefinition* class_definitions)
|
|
{ return p->RedefineClasses (this, class_count, class_definitions); }
|
|
|
|
jvmtiError GetVersionNumber (jint *version_ptr)
|
|
{ return p->GetVersionNumber (this, version_ptr); }
|
|
|
|
jvmtiError GetCapabilities (jvmtiCapabilities *capabilities_ptr)
|
|
{ return p->GetCapabilities (this, capabilities_ptr); }
|
|
|
|
jvmtiError GetSourceDebugExtension (jclass klass,
|
|
char **source_debug_extension_ptr)
|
|
{
|
|
return p->GetSourceDebugExtension (this, klass,
|
|
source_debug_extension_ptr);
|
|
}
|
|
|
|
jvmtiError IsMethodObsolete (jmethodID method, jboolean *is_obsolete_ptr)
|
|
{ return p->IsMethodObsolete (this, method, is_obsolete_ptr); }
|
|
|
|
|
|
jvmtiError SuspendThreadList (jint request_count,
|
|
const jthread *request_list,
|
|
jvmtiError *results)
|
|
{ return p->SuspendThreadList (this, request_count, request_list, results); }
|
|
|
|
jvmtiError ResumeThreadList (jint request_count,
|
|
const jthread *request_list,
|
|
jvmtiError *results)
|
|
{ return p->ResumeThreadList (this, request_count, request_list, results); }
|
|
|
|
jvmtiError GetAllStackTraces (jint max_frame_count,
|
|
jvmtiStackInfo **stack_info_ptr,
|
|
jint *thread_count_ptr)
|
|
{
|
|
return p->GetAllStackTraces (this, max_frame_count, stack_info_ptr,
|
|
thread_count_ptr);
|
|
}
|
|
|
|
jvmtiError GetThreadListStackTraces (jint thread_count,
|
|
const jthread *thread_list,
|
|
jint max_frame_count,
|
|
jvmtiStackInfo **stack_info_ptr)
|
|
{
|
|
return p->GetThreadListStackTraces (this, thread_count, thread_list,
|
|
max_frame_count, stack_info_ptr);
|
|
}
|
|
|
|
jvmtiError GetThreadLocalStorage (jthread thread, void **data_ptr)
|
|
{ return p->GetThreadLocalStorage (this, thread, data_ptr); }
|
|
|
|
jvmtiError SetThreadLocalStorage (jthread thread, const void *data)
|
|
{ return p->SetThreadLocalStorage (this, thread, data); }
|
|
|
|
jvmtiError GetStackTrace (jthread thread, jint start_depth,
|
|
jint max_frame_count,
|
|
jvmtiFrameInfo *frame_buffer, jint *count_ptr)
|
|
{
|
|
return p->GetStackTrace (this, thread, start_depth, max_frame_count,
|
|
frame_buffer, count_ptr);
|
|
}
|
|
|
|
jvmtiError GetTag (jobject object, jlong *tag_ptr)
|
|
{ return p->GetTag (this, object, tag_ptr); }
|
|
|
|
jvmtiError SetTag (jobject object, jlong tag)
|
|
{ return p->SetTag (this, object, tag); }
|
|
|
|
jvmtiError ForceGarbageCollection (void)
|
|
{ return p->ForceGarbageCollection (this); }
|
|
|
|
jvmtiError IterateOverObjectsReachableFromObject (jobject object,
|
|
jvmtiObjectReferenceCallback object_reference_callback,
|
|
void *user_data)
|
|
{
|
|
return p->IterateOverObjectsReachableFromObject (this, object,
|
|
object_reference_callback,
|
|
user_data);
|
|
}
|
|
|
|
jvmtiError IterateOverReachableObjects (jvmtiHeapRootCallback heap_root_callback,
|
|
jvmtiStackReferenceCallback stack_ref_callback,
|
|
jvmtiObjectReferenceCallback object_ref_callback,
|
|
void *user_data)
|
|
{
|
|
return p->IterateOverReachableObjects (this, heap_root_callback,
|
|
stack_ref_callback,
|
|
object_ref_callback,
|
|
user_data);
|
|
}
|
|
|
|
jvmtiError IterateOverHeap (jvmtiHeapObjectFilter object_filter,
|
|
jvmtiHeapObjectCallback heap_object_callback,
|
|
void *user_data)
|
|
{
|
|
return p->IterateOverHeap (this, object_filter, heap_object_callback,
|
|
user_data);
|
|
}
|
|
|
|
jvmtiError IterateOverInstanceOfClass (jclass klass,
|
|
jvmtiHeapObjectFilter object_filter,
|
|
jvmtiHeapObjectCallback heap_object_callback,
|
|
void *user_data)
|
|
{
|
|
return p->IterateOverInstanceOfClass (this, klass, object_filter,
|
|
heap_object_callback, user_data);
|
|
}
|
|
|
|
jvmtiError GetObjectsWithTags (jint tag_count, const jlong *tags,
|
|
jint *count_ptr, jobject **object_result_ptr,
|
|
jlong **tag_result_ptr)
|
|
{
|
|
return p->GetObjectsWithTags (this, tag_count, tags, count_ptr,
|
|
object_result_ptr, tag_result_ptr);
|
|
}
|
|
|
|
jvmtiError SetJNIFunctionTable (const jniNativeInterface *function_table)
|
|
{ return p->SetJNIFunctionTable (this, function_table); }
|
|
|
|
jvmtiError GetJNIFunctionTable (jniNativeInterface **function_table_ptr)
|
|
{ return p->GetJNIFunctionTable (this, function_table_ptr); }
|
|
|
|
jvmtiError SetEventCallbacks (const jvmtiEventCallbacks *callbacks,
|
|
jint size_of_callbacks)
|
|
{ return p->SetEventCallbacks (this, callbacks, size_of_callbacks); }
|
|
|
|
jvmtiError GenerateEvents (jvmtiEvent event_type)
|
|
{ return p->GenerateEvents (this, event_type); }
|
|
|
|
jvmtiError GetExtensionFunctions (jint *extension_count_ptr,
|
|
jvmtiExtensionFunctionInfo **extensions)
|
|
{ return p->GetExtensionFunctions (this, extension_count_ptr, extensions); }
|
|
|
|
jvmtiError GetExtensionEvents (jint *extension_count_ptr,
|
|
jvmtiExtensionEventInfo **extensions)
|
|
{ return p->GetExtensionEvents (this, extension_count_ptr, extensions); }
|
|
|
|
jvmtiError SetExtensionEventCallback (jint extension_event_index,
|
|
jvmtiExtensionEvent callback)
|
|
{
|
|
return p->SetExtensionEventCallback (this, extension_event_index,
|
|
callback);
|
|
}
|
|
|
|
jvmtiError DisposeEnvironment (void)
|
|
{ return p->DisposeEnvironment (this); }
|
|
|
|
jvmtiError GetErrorName (jvmtiError error, char **name_ptr)
|
|
{ return p->GetErrorName (this, error, name_ptr); }
|
|
|
|
jvmtiError GetJLocationFormat (jvmtiJlocationFormat *format_ptr)
|
|
{ return p->GetJLocationFormat (this, format_ptr); }
|
|
|
|
jvmtiError GetSystemProperties (jint *count_ptr, char ***property_ptr)
|
|
{ return p->GetSystemProperties (this, count_ptr, property_ptr); }
|
|
|
|
jvmtiError GetSystemProperty (const char *property, char **value_ptr)
|
|
{ return p->GetSystemProperty (this, property, value_ptr); }
|
|
|
|
jvmtiError SetSystemProperty (const char *property, const char *value)
|
|
{ return p->SetSystemProperty (this, property, value); }
|
|
|
|
jvmtiError GetPhase (jvmtiPhase *phase_ptr)
|
|
{ return p->GetPhase (this, phase_ptr); }
|
|
|
|
jvmtiError GetCurrentThreadCpuTimerInfo (jvmtiTimerInfo *info_ptr)
|
|
{ return p->GetCurrentThreadCpuTimerInfo (this, info_ptr); }
|
|
|
|
jvmtiError GetCurrentThreadCpuTime (jlong *nanos_ptr)
|
|
{ return p->GetCurrentThreadCpuTime (this, nanos_ptr); }
|
|
|
|
jvmtiError GetThreadCpuTimerInfo (jvmtiTimerInfo *info_ptr)
|
|
{ return p->GetThreadCpuTimerInfo (this, info_ptr); }
|
|
|
|
jvmtiError GetThreadCpuTime (jthread thread, jlong *nanos_ptr)
|
|
{ return p->GetThreadCpuTime (this, thread, nanos_ptr); }
|
|
|
|
jvmtiError GetTimerInfo (jvmtiTimerInfo *info_ptr)
|
|
{ return p->GetTimerInfo (this, info_ptr); }
|
|
|
|
jvmtiError GetTime (jlong *nanos_ptr)
|
|
{return p->GetTime (this, nanos_ptr); }
|
|
|
|
jvmtiError GetPotentialCapabilities (jvmtiCapabilities *capabilities_ptr)
|
|
{ return p->GetPotentialCapabilities (this, capabilities_ptr); }
|
|
|
|
jvmtiError AddCapabilities (const jvmtiCapabilities *capabilities_ptr)
|
|
{ return p->AddCapabilities (this, capabilities_ptr); }
|
|
|
|
jvmtiError RelinquishCapabilities (const jvmtiCapabilities *capabilities_ptr)
|
|
{ return p->RelinquishCapabilities (this, capabilities_ptr); }
|
|
|
|
jvmtiError GetAvailableProcessors (jint *processor_count_ptr)
|
|
{ return p->GetAvailableProcessors (this, processor_count_ptr); }
|
|
|
|
jvmtiError GetEnvironmentLocalStorage (void **data_ptr)
|
|
{ return p->GetEnvironmentLocalStorage (this, data_ptr); }
|
|
|
|
jvmtiError SetEnvironmentLocalStorage (const void *data)
|
|
{ return p->SetEnvironmentLocalStorage (this, data); }
|
|
|
|
jvmtiError AddToBootstrapClassLoaderSearch (const char *segment)
|
|
{ return p->AddToBootstrapClassLoaderSearch (this, segment); }
|
|
|
|
jvmtiError SetVerboseFlag (jvmtiVerboseFlag flag, jboolean value)
|
|
{ return p->SetVerboseFlag (this, flag, value); }
|
|
|
|
jvmtiError GetObjectSize (jobject object, jlong *size_ptr)
|
|
{ return p->GetObjectSize (this, object, size_ptr); }
|
|
};
|
|
#endif /* __cplusplus */
|
|
|
|
/*
|
|
* Miscellaneous flags, constants, etc
|
|
*/
|
|
|
|
/* Class status flags */
|
|
#define JVMTI_CLASS_STATUS_VERIFIED 1
|
|
#define JVMTI_CLASS_STATUS_PREPARED 2
|
|
#define JVMTI_CLASS_STATUS_INITIALIZED 4
|
|
#define JVMTI_CLASS_STATUS_ERROR 8
|
|
#define JVMTI_CLASS_STATUS_ARRAY 16
|
|
#define JVMTI_CLASS_STATUS_PRIMITIVE 32
|
|
|
|
/* Thread state flags */
|
|
#define JVMTI_THREAD_STATE_ALIVE 0x0001
|
|
#define JVMTI_THREAD_STATE_TERMINATED 0x0002
|
|
#define JVMTI_THREAD_STATE_RUNNABLE 0x0004
|
|
#define JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER 0x0400
|
|
#define JVMTI_THREAD_STATE_WAITING 0x0080
|
|
#define JVMTI_THREAD_STATE_WAITING_INDEFINITELY 0x0010
|
|
#define JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT 0x0020
|
|
#define JVMTI_THREAD_STATE_SLEEPING 0x0040
|
|
#define JVMTI_THREAD_STATE_IN_OBJECT_WAIT 0x0100
|
|
#define JVMTI_THREAD_STATE_PARKED 0x0200
|
|
#define JVMTI_THREAD_STATE_SUSPENDED 0x100000
|
|
#define JVMTI_THREAD_STATE_INTERRUPTED 0x200000
|
|
#define JVMTI_THREAD_STATE_IN_NATIVE 0x400000
|
|
#define JVMTI_THREAD_STATE_VENDOR_1 0x10000000
|
|
#define JVMTI_THREAD_STATE_VENDOR_2 0x20000000
|
|
#define JVMTI_THREAD_STATE_VENDOR_3 0x40000000
|
|
|
|
/* java.lang.Thread.State conversion masks */
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_MASK \
|
|
(JVMTI_THREAD_STATE_TERMINATED \
|
|
| JVMTI_THREAD_STATE_ALIVE \
|
|
| JVMTI_THREAD_STATE_RUNNABLE \
|
|
| JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER \
|
|
| JVMTI_THREAD_STATE_WAITING \
|
|
| JVMTI_THREAD_STATE_WAITING_INDEFINITELY \
|
|
| JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT)
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_NEW 0
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED JVMTI_THREAD_STATE_TERMINATED
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE \
|
|
(JVMTI_THREAD_STATE_ALIVE \
|
|
| JVMTI_THREAD_STATE_RUNNABLE)
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED \
|
|
(JVMTI_THREAD_STATE_ALIVE \
|
|
| JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER)
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_WAITING \
|
|
(JVMTI_THREAD_STATE_ALIVE \
|
|
| JVMTI_THREAD_STATE_WAITING \
|
|
| JVMTI_THREAD_STATE_WAITING_INDEFINITELY)
|
|
#define JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING \
|
|
(JVMTI_THREAD_STATE_ALIVE \
|
|
| JVMTI_THREAD_STATE_WAITING \
|
|
| JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT)
|
|
|
|
/* Thread priorities */
|
|
#define JVMTI_THREAD_MIN_PRIORITY 1
|
|
#define JVMTI_THREAD_NORM_PRIORITY 5
|
|
#define JVMTI_THREAD_MAX_PRIORITY 10
|
|
|
|
/* Keep c-font-lock-extra-types in order: JNI followed by JVMTI,
|
|
all in alphabetical order */
|
|
/* Local Variables: */
|
|
/* c-font-lock-extra-types: ("\\sw+_t"
|
|
"JNIEnv" "JNINativeMethod" "JavaVM" "JavaVMOption" "jarray"
|
|
"jboolean" "jbooleanArray" "jbyte" "jbyteArray" "jchar" "jcharArray"
|
|
"jclass" "jdouble" "jdoubleArray" "jfieldID" "jfloat" "jfloatArray"
|
|
"jint" "jintArray" "jlong" "jlongArray" "jmethodID" "jobject" "jstring" "jthrowable"
|
|
"jvalue" "jweak"
|
|
"jvmtiEnv" "jvmtiError"
|
|
"jthread" "jthreadGroup" "jlocation" "jrawMonitorID") */
|
|
/* End: */
|
|
#endif /* !_CLASSPATH_JVMTI_H */
|