From a959c53b7ac91e489bf0959391e892790b9ff248 Mon Sep 17 00:00:00 2001
From: Kenneth Russel <kbrussel@alum.mit.edu>
Date: Mon, 15 Jun 2009 22:57:38 +0000
Subject: Copied JOGL_2_SANDBOX r1957 on to trunk; JOGL_2_SANDBOX branch is now
closed
git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@1959 232f8b59-042b-4e1e-8c03-345bb8c30851
---
make/stub_includes/jni/macosx/AWTCocoaComponent.h | 15 +
make/stub_includes/jni/macosx/JDWP.h | 53 ++
make/stub_includes/jni/macosx/JDWPCommands.h | 238 +++++
make/stub_includes/jni/macosx/jawt_md.h | 27 +
make/stub_includes/jni/macosx/jni_md.h | 23 +
make/stub_includes/jni/macosx/jvmdi.h | 1012 +++++++++++++++++++++
make/stub_includes/jni/macosx/jvmpi.h | 642 +++++++++++++
7 files changed, 2010 insertions(+)
create mode 100644 make/stub_includes/jni/macosx/AWTCocoaComponent.h
create mode 100644 make/stub_includes/jni/macosx/JDWP.h
create mode 100644 make/stub_includes/jni/macosx/JDWPCommands.h
create mode 100644 make/stub_includes/jni/macosx/jawt_md.h
create mode 100644 make/stub_includes/jni/macosx/jni_md.h
create mode 100644 make/stub_includes/jni/macosx/jvmdi.h
create mode 100644 make/stub_includes/jni/macosx/jvmpi.h
(limited to 'make/stub_includes/jni/macosx')
diff --git a/make/stub_includes/jni/macosx/AWTCocoaComponent.h b/make/stub_includes/jni/macosx/AWTCocoaComponent.h
new file mode 100644
index 000000000..8f004c5c0
--- /dev/null
+++ b/make/stub_includes/jni/macosx/AWTCocoaComponent.h
@@ -0,0 +1,15 @@
+//
+// AWTCocoaComponent.h
+//
+// Copyright (c) 2003 Apple Computer Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <JavaVM/jni.h>
+
+// This is implemented by a com.apple.eawt.CocoaComponent. It receives messages
+// from java safely on the AppKit thread. See the com.apple.eawt.CocoaComponent
+// java documentation for more information.
+@protocol AWTCocoaComponent
+-(void)awtMessage:(jint)messageID message:(jobject)message env:(JNIEnv*)env;
+@end
diff --git a/make/stub_includes/jni/macosx/JDWP.h b/make/stub_includes/jni/macosx/JDWP.h
new file mode 100644
index 000000000..9f359e06c
--- /dev/null
+++ b/make/stub_includes/jni/macosx/JDWP.h
@@ -0,0 +1,53 @@
+/*
+ * @(#)JDWP.h 1.31 03/12/19
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef JDWP_JDWP_H
+#define JDWP_JDWP_H
+
+#include "JDWPCommands.h"
+
+/*
+ * JDWPCommands.h is the javah'ed version of all the constants defined
+ * com.sun.tools.jdi.JDWP and all its nested classes. Since the names are
+ * very long, the macros below are provided for convenience.
+ */
+
+#define JDWP_COMMAND_SET(name) JDWP_ ## name
+#define JDWP_COMMAND(set, name) JDWP_ ## set ## _ ## name
+#define JDWP_REQUEST_MODIFIER(name) \
+ JDWP_EventRequest_Set_Out_modifiers_Modifier_ ## name
+#define JDWP_EVENT(name) \
+ JDWP_EventKind_ ## name
+#define JDWP_THREAD_STATUS(name) \
+ JDWP_ThreadStatus_ ## name
+#define JDWP_SUSPEND_STATUS(name) \
+ JDWP_SuspendStatus_SUSPEND_STATUS_ ## name
+#define JDWP_CLASS_STATUS(name) \
+ JDWP_ClassStatus_ ## name
+#define JDWP_TYPE_TAG(name) \
+ JDWP_TypeTag_ ## name
+#define JDWP_TAG(name) \
+ JDWP_Tag_ ## name
+#define JDWP_STEP_DEPTH(name) \
+ JDWP_StepDepth_ ## name
+#define JDWP_STEP_SIZE(name) \
+ JDWP_StepSize_ ## name
+#define JDWP_SUSPEND_POLICY(name) \
+ JDWP_SuspendPolicy_ ## name
+#define JDWP_INVOKE_OPTIONS(name) \
+ JDWP_InvokeOptions_INVOKE_ ## name
+#define JDWP_ERROR(name) \
+ JDWP_Error_ ## name
+#define JDWP_HIGHEST_COMMAND_SET 17
+#define JDWP_REQUEST_NONE -1
+
+/* This typedef helps keep the event and error types straight. */
+typedef unsigned short jdwpError;
+typedef unsigned char jdwpEvent;
+typedef jint jdwpThreadStatus;
+
+#endif
diff --git a/make/stub_includes/jni/macosx/JDWPCommands.h b/make/stub_includes/jni/macosx/JDWPCommands.h
new file mode 100644
index 000000000..f5011b25f
--- /dev/null
+++ b/make/stub_includes/jni/macosx/JDWPCommands.h
@@ -0,0 +1,238 @@
+#define JDWP_VirtualMachine 1
+#define JDWP_VirtualMachine_Version 1
+#define JDWP_VirtualMachine_ClassesBySignature 2
+#define JDWP_VirtualMachine_AllClasses 3
+#define JDWP_VirtualMachine_AllThreads 4
+#define JDWP_VirtualMachine_TopLevelThreadGroups 5
+#define JDWP_VirtualMachine_Dispose 6
+#define JDWP_VirtualMachine_IDSizes 7
+#define JDWP_VirtualMachine_Suspend 8
+#define JDWP_VirtualMachine_Resume 9
+#define JDWP_VirtualMachine_Exit 10
+#define JDWP_VirtualMachine_CreateString 11
+#define JDWP_VirtualMachine_Capabilities 12
+#define JDWP_VirtualMachine_ClassPaths 13
+#define JDWP_VirtualMachine_DisposeObjects 14
+#define JDWP_VirtualMachine_HoldEvents 15
+#define JDWP_VirtualMachine_ReleaseEvents 16
+#define JDWP_VirtualMachine_CapabilitiesNew 17
+#define JDWP_VirtualMachine_RedefineClasses 18
+#define JDWP_VirtualMachine_SetDefaultStratum 19
+#define JDWP_VirtualMachine_AllClassesWithGeneric 20
+#define JDWP_ReferenceType 2
+#define JDWP_ReferenceType_Signature 1
+#define JDWP_ReferenceType_ClassLoader 2
+#define JDWP_ReferenceType_Modifiers 3
+#define JDWP_ReferenceType_Fields 4
+#define JDWP_ReferenceType_Methods 5
+#define JDWP_ReferenceType_GetValues 6
+#define JDWP_ReferenceType_SourceFile 7
+#define JDWP_ReferenceType_NestedTypes 8
+#define JDWP_ReferenceType_Status 9
+#define JDWP_ReferenceType_Interfaces 10
+#define JDWP_ReferenceType_ClassObject 11
+#define JDWP_ReferenceType_SourceDebugExtension 12
+#define JDWP_ReferenceType_SignatureWithGeneric 13
+#define JDWP_ReferenceType_FieldsWithGeneric 14
+#define JDWP_ReferenceType_MethodsWithGeneric 15
+#define JDWP_ClassType 3
+#define JDWP_ClassType_Superclass 1
+#define JDWP_ClassType_SetValues 2
+#define JDWP_ClassType_InvokeMethod 3
+#define JDWP_ClassType_NewInstance 4
+#define JDWP_ArrayType 4
+#define JDWP_ArrayType_NewInstance 1
+#define JDWP_InterfaceType 5
+#define JDWP_Method 6
+#define JDWP_Method_LineTable 1
+#define JDWP_Method_VariableTable 2
+#define JDWP_Method_Bytecodes 3
+#define JDWP_Method_IsObsolete 4
+#define JDWP_Method_VariableTableWithGeneric 5
+#define JDWP_Field 8
+#define JDWP_ObjectReference 9
+#define JDWP_ObjectReference_ReferenceType 1
+#define JDWP_ObjectReference_GetValues 2
+#define JDWP_ObjectReference_SetValues 3
+#define JDWP_ObjectReference_MonitorInfo 5
+#define JDWP_ObjectReference_InvokeMethod 6
+#define JDWP_ObjectReference_DisableCollection 7
+#define JDWP_ObjectReference_EnableCollection 8
+#define JDWP_ObjectReference_IsCollected 9
+#define JDWP_StringReference 10
+#define JDWP_StringReference_Value 1
+#define JDWP_ThreadReference 11
+#define JDWP_ThreadReference_Name 1
+#define JDWP_ThreadReference_Suspend 2
+#define JDWP_ThreadReference_Resume 3
+#define JDWP_ThreadReference_Status 4
+#define JDWP_ThreadReference_ThreadGroup 5
+#define JDWP_ThreadReference_Frames 6
+#define JDWP_ThreadReference_FrameCount 7
+#define JDWP_ThreadReference_OwnedMonitors 8
+#define JDWP_ThreadReference_CurrentContendedMonitor 9
+#define JDWP_ThreadReference_Stop 10
+#define JDWP_ThreadReference_Interrupt 11
+#define JDWP_ThreadReference_SuspendCount 12
+#define JDWP_ThreadGroupReference 12
+#define JDWP_ThreadGroupReference_Name 1
+#define JDWP_ThreadGroupReference_Parent 2
+#define JDWP_ThreadGroupReference_Children 3
+#define JDWP_ArrayReference 13
+#define JDWP_ArrayReference_Length 1
+#define JDWP_ArrayReference_GetValues 2
+#define JDWP_ArrayReference_SetValues 3
+#define JDWP_ClassLoaderReference 14
+#define JDWP_ClassLoaderReference_VisibleClasses 1
+#define JDWP_EventRequest 15
+#define JDWP_EventRequest_Set 1
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_Count 1
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_Conditional 2
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_ThreadOnly 3
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassOnly 4
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassMatch 5
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassExclude 6
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly 7
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_ExceptionOnly 8
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_FieldOnly 9
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_Step 10
+#define JDWP_EventRequest_Set_Out_modifiers_Modifier_InstanceOnly 11
+#define JDWP_EventRequest_Clear 2
+#define JDWP_EventRequest_ClearAllBreakpoints 3
+#define JDWP_StackFrame 16
+#define JDWP_StackFrame_GetValues 1
+#define JDWP_StackFrame_SetValues 2
+#define JDWP_StackFrame_ThisObject 3
+#define JDWP_StackFrame_PopFrames 4
+#define JDWP_ClassObjectReference 17
+#define JDWP_ClassObjectReference_ReflectedType 1
+#define JDWP_Event 64
+#define JDWP_Event_Composite 100
+#define JDWP_Event_Composite_Event_events_Events_VMStart JDWP.EventKind.VM_START
+#define JDWP_Event_Composite_Event_events_Events_SingleStep JDWP.EventKind.SINGLE_STEP
+#define JDWP_Event_Composite_Event_events_Events_Breakpoint JDWP.EventKind.BREAKPOINT
+#define JDWP_Event_Composite_Event_events_Events_MethodEntry JDWP.EventKind.METHOD_ENTRY
+#define JDWP_Event_Composite_Event_events_Events_MethodExit JDWP.EventKind.METHOD_EXIT
+#define JDWP_Event_Composite_Event_events_Events_Exception JDWP.EventKind.EXCEPTION
+#define JDWP_Event_Composite_Event_events_Events_ThreadStart JDWP.EventKind.THREAD_START
+#define JDWP_Event_Composite_Event_events_Events_ThreadDeath JDWP.EventKind.THREAD_DEATH
+#define JDWP_Event_Composite_Event_events_Events_ClassPrepare JDWP.EventKind.CLASS_PREPARE
+#define JDWP_Event_Composite_Event_events_Events_ClassUnload JDWP.EventKind.CLASS_UNLOAD
+#define JDWP_Event_Composite_Event_events_Events_FieldAccess JDWP.EventKind.FIELD_ACCESS
+#define JDWP_Event_Composite_Event_events_Events_FieldModification JDWP.EventKind.FIELD_MODIFICATION
+#define JDWP_Event_Composite_Event_events_Events_VMDeath JDWP.EventKind.VM_DEATH
+#define JDWP_Error_NONE 0
+#define JDWP_Error_INVALID_THREAD 10
+#define JDWP_Error_INVALID_THREAD_GROUP 11
+#define JDWP_Error_INVALID_PRIORITY 12
+#define JDWP_Error_THREAD_NOT_SUSPENDED 13
+#define JDWP_Error_THREAD_SUSPENDED 14
+#define JDWP_Error_INVALID_OBJECT 20
+#define JDWP_Error_INVALID_CLASS 21
+#define JDWP_Error_CLASS_NOT_PREPARED 22
+#define JDWP_Error_INVALID_METHODID 23
+#define JDWP_Error_INVALID_LOCATION 24
+#define JDWP_Error_INVALID_FIELDID 25
+#define JDWP_Error_INVALID_FRAMEID 30
+#define JDWP_Error_NO_MORE_FRAMES 31
+#define JDWP_Error_OPAQUE_FRAME 32
+#define JDWP_Error_NOT_CURRENT_FRAME 33
+#define JDWP_Error_TYPE_MISMATCH 34
+#define JDWP_Error_INVALID_SLOT 35
+#define JDWP_Error_DUPLICATE 40
+#define JDWP_Error_NOT_FOUND 41
+#define JDWP_Error_INVALID_MONITOR 50
+#define JDWP_Error_NOT_MONITOR_OWNER 51
+#define JDWP_Error_INTERRUPT 52
+#define JDWP_Error_INVALID_CLASS_FORMAT 60
+#define JDWP_Error_CIRCULAR_CLASS_DEFINITION 61
+#define JDWP_Error_FAILS_VERIFICATION 62
+#define JDWP_Error_ADD_METHOD_NOT_IMPLEMENTED 63
+#define JDWP_Error_SCHEMA_CHANGE_NOT_IMPLEMENTED 64
+#define JDWP_Error_INVALID_TYPESTATE 65
+#define JDWP_Error_HIERARCHY_CHANGE_NOT_IMPLEMENTED 66
+#define JDWP_Error_DELETE_METHOD_NOT_IMPLEMENTED 67
+#define JDWP_Error_UNSUPPORTED_VERSION 68
+#define JDWP_Error_NAMES_DONT_MATCH 69
+#define JDWP_Error_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED 70
+#define JDWP_Error_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED 71
+#define JDWP_Error_NOT_IMPLEMENTED 99
+#define JDWP_Error_NULL_POINTER 100
+#define JDWP_Error_ABSENT_INFORMATION 101
+#define JDWP_Error_INVALID_EVENT_TYPE 102
+#define JDWP_Error_ILLEGAL_ARGUMENT 103
+#define JDWP_Error_OUT_OF_MEMORY 110
+#define JDWP_Error_ACCESS_DENIED 111
+#define JDWP_Error_VM_DEAD 112
+#define JDWP_Error_INTERNAL 113
+#define JDWP_Error_UNATTACHED_THREAD 115
+#define JDWP_Error_INVALID_TAG 500
+#define JDWP_Error_ALREADY_INVOKING 502
+#define JDWP_Error_INVALID_INDEX 503
+#define JDWP_Error_INVALID_LENGTH 504
+#define JDWP_Error_INVALID_STRING 506
+#define JDWP_Error_INVALID_CLASS_LOADER 507
+#define JDWP_Error_INVALID_ARRAY 508
+#define JDWP_Error_TRANSPORT_LOAD 509
+#define JDWP_Error_TRANSPORT_INIT 510
+#define JDWP_Error_NATIVE_METHOD 511
+#define JDWP_Error_INVALID_COUNT 512
+#define JDWP_EventKind_VM_DISCONNECTED 100
+#define JDWP_EventKind_VM_START JDWP.EventKind.VM_INIT
+#define JDWP_EventKind_THREAD_DEATH JDWP.EventKind.THREAD_END
+#define JDWP_EventKind_SINGLE_STEP 1
+#define JDWP_EventKind_BREAKPOINT 2
+#define JDWP_EventKind_FRAME_POP 3
+#define JDWP_EventKind_EXCEPTION 4
+#define JDWP_EventKind_USER_DEFINED 5
+#define JDWP_EventKind_THREAD_START 6
+#define JDWP_EventKind_THREAD_END 7
+#define JDWP_EventKind_CLASS_PREPARE 8
+#define JDWP_EventKind_CLASS_UNLOAD 9
+#define JDWP_EventKind_CLASS_LOAD 10
+#define JDWP_EventKind_FIELD_ACCESS 20
+#define JDWP_EventKind_FIELD_MODIFICATION 21
+#define JDWP_EventKind_EXCEPTION_CATCH 30
+#define JDWP_EventKind_METHOD_ENTRY 40
+#define JDWP_EventKind_METHOD_EXIT 41
+#define JDWP_EventKind_VM_INIT 90
+#define JDWP_EventKind_VM_DEATH 99
+#define JDWP_ThreadStatus_ZOMBIE 0
+#define JDWP_ThreadStatus_RUNNING 1
+#define JDWP_ThreadStatus_SLEEPING 2
+#define JDWP_ThreadStatus_MONITOR 3
+#define JDWP_ThreadStatus_WAIT 4
+#define JDWP_SuspendStatus_SUSPEND_STATUS_SUSPENDED 0x1
+#define JDWP_ClassStatus_VERIFIED 1
+#define JDWP_ClassStatus_PREPARED 2
+#define JDWP_ClassStatus_INITIALIZED 4
+#define JDWP_ClassStatus_ERROR 8
+#define JDWP_TypeTag_CLASS 1
+#define JDWP_TypeTag_INTERFACE 2
+#define JDWP_TypeTag_ARRAY 3
+#define JDWP_Tag_ARRAY 91
+#define JDWP_Tag_BYTE 66
+#define JDWP_Tag_CHAR 67
+#define JDWP_Tag_OBJECT 76
+#define JDWP_Tag_FLOAT 70
+#define JDWP_Tag_DOUBLE 68
+#define JDWP_Tag_INT 73
+#define JDWP_Tag_LONG 74
+#define JDWP_Tag_SHORT 83
+#define JDWP_Tag_VOID 86
+#define JDWP_Tag_BOOLEAN 90
+#define JDWP_Tag_STRING 115
+#define JDWP_Tag_THREAD 116
+#define JDWP_Tag_THREAD_GROUP 103
+#define JDWP_Tag_CLASS_LOADER 108
+#define JDWP_Tag_CLASS_OBJECT 99
+#define JDWP_StepDepth_INTO 0
+#define JDWP_StepDepth_OVER 1
+#define JDWP_StepDepth_OUT 2
+#define JDWP_StepSize_MIN 0
+#define JDWP_StepSize_LINE 1
+#define JDWP_SuspendPolicy_NONE 0
+#define JDWP_SuspendPolicy_EVENT_THREAD 1
+#define JDWP_SuspendPolicy_ALL 2
+#define JDWP_InvokeOptions_INVOKE_SINGLE_THREADED 0x01
+#define JDWP_InvokeOptions_INVOKE_NONVIRTUAL 0x02
diff --git a/make/stub_includes/jni/macosx/jawt_md.h b/make/stub_includes/jni/macosx/jawt_md.h
new file mode 100644
index 000000000..aca47f66e
--- /dev/null
+++ b/make/stub_includes/jni/macosx/jawt_md.h
@@ -0,0 +1,27 @@
+//
+// jawt_md.h
+//
+// Copyright (c) 2002 Apple computer Inc. All rights reserved.
+//
+
+#ifndef _JAVASOFT_JAWT_MD_H_
+#define _JAVASOFT_JAWT_MD_H_
+
+#include <jawt.h>
+#include <AppKit/NSView.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct JAWT_MacOSXDrawingSurfaceInfo
+{
+ NSView *cocoaViewRef; // the view is guaranteed to be valid only for the duration of Component.paint method
+}
+JAWT_MacOSXDrawingSurfaceInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_JAVASOFT_JAWT_MD_H_ */
diff --git a/make/stub_includes/jni/macosx/jni_md.h b/make/stub_includes/jni/macosx/jni_md.h
new file mode 100644
index 000000000..86b5ad230
--- /dev/null
+++ b/make/stub_includes/jni/macosx/jni_md.h
@@ -0,0 +1,23 @@
+/*
+ * @(#)jni_md.h 1.18 03/12/19
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JNI_MD_H_
+#define _JAVASOFT_JNI_MD_H_
+
+#define JNIEXPORT __attribute__((visibility("default")))
+#define JNIIMPORT
+#define JNICALL
+
+#if __LP64__
+typedef int jint;
+#else
+typedef long jint;
+#endif
+typedef long long jlong;
+typedef signed char jbyte;
+
+#endif /* !_JAVASOFT_JNI_MD_H_ */
diff --git a/make/stub_includes/jni/macosx/jvmdi.h b/make/stub_includes/jni/macosx/jvmdi.h
new file mode 100644
index 000000000..81e559db7
--- /dev/null
+++ b/make/stub_includes/jni/macosx/jvmdi.h
@@ -0,0 +1,1012 @@
+/*
+ * @(#)jvmdi.h 1.48 03/12/19
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/*
+ * Java Virtual Machine Debug Interface
+ *
+ * Defines debugging functionality that a VM should provide.
+ *
+ * Should not overlap functionality in jni.h
+ */
+
+#ifndef _JAVASOFT_JVMDI_H_
+#define _JAVASOFT_JVMDI_H_
+
+#include "jni.h"
+
+#define JVMDI_VERSION_1 0x20010000
+#define JVMDI_VERSION_1_1 0x20010001
+#define JVMDI_VERSION_1_2 0x20010002
+#define JVMDI_VERSION_1_3 0x20010003
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef jobject jthread;
+
+typedef jobject jthreadGroup;
+
+struct _jframeID;
+typedef struct _jframeID *jframeID;
+
+ /* specifies program location "pc" - often byte code index */
+typedef jlong jlocation;
+
+ /* The jmethodID for methods that have been replaced */
+ /* via RedefineClasses - used when the implementation */
+ /* does not wish to retain replaced jmethodIDs */
+#define OBSOLETE_METHOD_ID ((jmethodID)(NULL))
+
+ /*
+ * Errors
+ */
+
+typedef jint jvmdiError;
+
+ /* no error */
+#define JVMDI_ERROR_NONE ((jvmdiError)0)
+
+ /*
+ * Errors on thread operations
+ */
+
+ /* invalid thread */
+#define JVMDI_ERROR_INVALID_THREAD ((jvmdiError)10)
+ /* invalid thread group */
+#define JVMDI_ERROR_INVALID_THREAD_GROUP ((jvmdiError)11)
+ /* invalid thread priority */
+#define JVMDI_ERROR_INVALID_PRIORITY ((jvmdiError)12)
+ /* thread not suspended */
+#define JVMDI_ERROR_THREAD_NOT_SUSPENDED ((jvmdiError)13)
+ /* thread already suspended */
+#define JVMDI_ERROR_THREAD_SUSPENDED ((jvmdiError)14)
+
+ /*
+ * Errors on object and class operations
+ */
+
+ /* invalid object (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_OBJECT ((jvmdiError)20)
+ /* invalid class (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_CLASS ((jvmdiError)21)
+ /* class not prepared */
+#define JVMDI_ERROR_CLASS_NOT_PREPARED ((jvmdiError)22)
+ /* invalid methodID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_METHODID ((jvmdiError)23)
+ /* invalid location */
+#define JVMDI_ERROR_INVALID_LOCATION ((jvmdiError)24)
+ /* invalid fieldID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_FIELDID ((jvmdiError)25)
+
+ /*
+ * Errors on frame operations
+ */
+
+ /* invalid frameID (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_INVALID_FRAMEID ((jvmdiError)30)
+ /* there are no more frames on the stack */
+#define JVMDI_ERROR_NO_MORE_FRAMES ((jvmdiError)31)
+ /* operation cannot be performed on this frame */
+#define JVMDI_ERROR_OPAQUE_FRAME ((jvmdiError)32)
+ /* operation can only be performed on current frame */
+#define JVMDI_ERROR_NOT_CURRENT_FRAME ((jvmdiError)33)
+ /* type mismatch (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_TYPE_MISMATCH ((jvmdiError)34)
+ /* invalid slot */
+#define JVMDI_ERROR_INVALID_SLOT ((jvmdiError)35)
+
+ /*
+ * Errors on set/clear/find operations
+ */
+
+ /* item already present */
+#define JVMDI_ERROR_DUPLICATE ((jvmdiError)40)
+ /* item not found */
+#define JVMDI_ERROR_NOT_FOUND ((jvmdiError)41)
+
+ /*
+ * Errors on monitor operations
+ */
+
+ /* invalid monitor */
+#define JVMDI_ERROR_INVALID_MONITOR ((jvmdiError)50)
+ /* wait, notify, notify all tried without entering monitor */
+#define JVMDI_ERROR_NOT_MONITOR_OWNER ((jvmdiError)51)
+ /* waiting thread interrupted */
+#define JVMDI_ERROR_INTERRUPT ((jvmdiError)52)
+
+ /*
+ * Class redefinition / operand stack errors
+ */
+
+ /* The equivalent of ClassFormatError */
+#define JVMDI_ERROR_INVALID_CLASS_FORMAT ((jvmdiError)60)
+ /* The equivalent of ClassCircularityError */
+#define JVMDI_ERROR_CIRCULAR_CLASS_DEFINITION ((jvmdiError)61)
+ /* The class bytes fail verification */
+#define JVMDI_ERROR_FAILS_VERIFICATION ((jvmdiError)62)
+ /* The new class version adds new methods */
+ /* and can_add_method is false */
+#define JVMDI_ERROR_ADD_METHOD_NOT_IMPLEMENTED ((jvmdiError)63)
+ /* The new class version changes fields */
+ /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED ((jvmdiError)64)
+ /* bci/operand stack/local var combination is not verifiably */
+ /* type safe */
+#define JVMDI_ERROR_INVALID_TYPESTATE ((jvmdiError)65)
+ /* A direct superclass is different for the new class */
+ /* version, or the set of directly implemented */
+ /* interfaces is different */
+ /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_HIERARCHY_CHANGE_NOT_IMPLEMENTED ((jvmdiError)66)
+ /* The new class version does not declare a method */
+ /* declared in the old class version */
+ /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_DELETE_METHOD_NOT_IMPLEMENTED ((jvmdiError)67)
+ /* A class file has a version number not supported */
+ /* by this VM. */
+#define JVMDI_ERROR_UNSUPPORTED_VERSION ((jvmdiError)68)
+ /* The class name defined in the new class file is */
+ /* different from the name in the old class object */
+#define JVMDI_ERROR_NAMES_DONT_MATCH ((jvmdiError)69)
+ /* The new class version has different modifiers and */
+ /* can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED ((jvmdiError)70)
+ /* A method in the new class version has different modifiers */
+ /* than its counterpart in the old class version */
+ /* and can_unrestrictedly_redefine_classes is false */
+#define JVMDI_ERROR_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED ((jvmdiError)71)
+
+ /*
+ * Miscellaneous errors
+ */
+
+ /* Not yet implemented */
+#define JVMDI_ERROR_NOT_IMPLEMENTED ((jvmdiError)99)
+ /* null pointer */
+#define JVMDI_ERROR_NULL_POINTER ((jvmdiError)100)
+ /* information is absent */
+#define JVMDI_ERROR_ABSENT_INFORMATION ((jvmdiError)101)
+ /* invalid event type */
+#define JVMDI_ERROR_INVALID_EVENT_TYPE ((jvmdiError)102)
+ /* invalid argument */
+#define JVMDI_ERROR_ILLEGAL_ARGUMENT ((jvmdiError)103)
+
+ /*
+ * Universal errors. These errors may be returned by
+ * any JVMDI function, not just the ones for which they are listed
+ * below.
+ */
+
+ /* no more memory available for allocation */
+#define JVMDI_ERROR_OUT_OF_MEMORY ((jvmdiError)110)
+ /* debugging has not been enabled in this VM */
+#define JVMDI_ERROR_ACCESS_DENIED ((jvmdiError)111)
+ /* VM is dead (implementation not required to gracefully catch) */
+#define JVMDI_ERROR_VM_DEAD ((jvmdiError)112)
+ /* internal error */
+#define JVMDI_ERROR_INTERNAL ((jvmdiError)113)
+ /* Thread calling JVMDI function not attached to VM */
+#define JVMDI_ERROR_UNATTACHED_THREAD ((jvmdiError)115)
+
+
+ /*
+ * Threads
+ */
+
+ /* Thread status is unknown */
+#define JVMDI_THREAD_STATUS_UNKNOWN ((jint)-1)
+ /* Thread is waiting to die */
+#define JVMDI_THREAD_STATUS_ZOMBIE ((jint)0)
+ /* Thread is runnable */
+#define JVMDI_THREAD_STATUS_RUNNING ((jint)1)
+ /* Thread is sleeping - Thread.sleep() or JVM_Sleep() was called */
+#define JVMDI_THREAD_STATUS_SLEEPING ((jint)2)
+ /* Thread is waiting on a java monitor */
+#define JVMDI_THREAD_STATUS_MONITOR ((jint)3)
+ /* Thread is waiting - Thread.wait() or JVM_MonitorWait() was called */
+#define JVMDI_THREAD_STATUS_WAIT ((jint)4)
+
+ /* Thread is suspended - Thread.suspend(), JVM_Suspend() or
+ * JVMDI_Suspend was called */
+#define JVMDI_SUSPEND_STATUS_SUSPENDED ((jint)0x1)
+ /* Thread is at a breakpoint */
+#define JVMDI_SUSPEND_STATUS_BREAK ((jint)0x2)
+
+
+ /* Thread priority constants */
+#define JVMDI_THREAD_MIN_PRIORITY ((jint)1)
+#define JVMDI_THREAD_NORM_PRIORITY ((jint)5)
+#define JVMDI_THREAD_MAX_PRIORITY ((jint)10)
+
+typedef struct {
+ char *name;
+ jint priority;
+ jboolean is_daemon;
+ jthreadGroup thread_group;
+ jobject context_class_loader;
+} JVMDI_thread_info;
+
+typedef struct {
+ jthreadGroup parent;
+ char *name;
+ jint max_priority;
+ jboolean is_daemon;
+} JVMDI_thread_group_info;
+
+#define JVMDI_DISABLE ((jint) 0)
+#define JVMDI_ENABLE ((jint) 1)
+
+/*
+ * Initial function for debug threads created through JVMDI
+ */
+typedef void (*JVMDI_StartFunction)(void *);
+
+/*
+ * Type for debug monitors created through JVMDI
+ */
+typedef void *JVMDI_RawMonitor;
+
+#define JVMDI_MONITOR_WAIT_FOREVER ((jlong)(0))
+
+/*
+ * Monitor information
+ */
+typedef struct {
+ jthread owner;
+ jint entry_count;
+ jint waiter_count;
+ jthread *waiters;
+} JVMDI_monitor_info;
+
+typedef struct {
+ jint owned_monitor_count;
+ jobject *owned_monitors;
+} JVMDI_owned_monitor_info;
+
+ /*
+ * Events
+ */
+
+ /* kind = JVMDI_EVENT_SINGLE_STEP */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ } JVMDI_single_step_event_data;
+
+ /* kind = JVMDI_EVENT_BREAKPOINT */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ } JVMDI_breakpoint_event_data;
+
+ /* kind = JVMDI_EVENT_FIELD_ACCESS */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ jclass field_clazz;
+ jobject object;
+ jfieldID field;
+ } JVMDI_field_access_event_data;
+
+ /* kind = JVMDI_EVENT_FIELD_MODIFICATION */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ jclass field_clazz;
+ jobject object;
+ jfieldID field;
+ char signature_type;
+ jvalue new_value;
+ } JVMDI_field_modification_event_data;
+
+ /* kind = JVMDI_EVENT_FRAME_POP */
+ /* kind = JVMDI_EVENT_METHOD_ENTRY */
+ /* kind = JVMDI_EVENT_METHOD_EXIT */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jframeID frame;
+ } JVMDI_frame_event_data;
+
+ /* kind = JVMDI_EVENT_EXCEPTION */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ jobject exception;
+ jclass catch_clazz;
+ jmethodID catch_method;
+ jlocation catch_location;
+ } JVMDI_exception_event_data;
+
+ /* kind = JVMDI_EVENT_EXCEPTION_CATCH */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ jmethodID method;
+ jlocation location;
+ jobject exception;
+ } JVMDI_exception_catch_event_data;
+
+ /* kind = JVMDI_EVENT_USER_DEFINED */
+ typedef struct {
+ jobject object;
+ jint key;
+ } JVMDI_user_event_data;
+
+ /* kind = JVMDI_EVENT_THREAD_END or */
+ /* JVMDI_EVENT_THREAD_START */
+ typedef struct {
+ jthread thread;
+ } JVMDI_thread_change_event_data;
+
+ /* kind = JVMDI_EVENT_CLASS_LOAD, */
+ /* JVMDI_EVENT_CLASS_UNLOAD, or */
+ /* JVMDI_EVENT_CLASS_PREPARE */
+ typedef struct {
+ jthread thread;
+ jclass clazz;
+ } JVMDI_class_event_data;
+
+/* This stucture passes information about the event.
+ * location is the index of the last instruction executed.
+ */
+typedef struct {
+ jint kind; /* the discriminant */
+
+ union {
+ /* kind = JVMDI_EVENT_SINGLE_STEP */
+ JVMDI_single_step_event_data single_step;
+
+ /* kind = JVMDI_EVENT_BREAKPOINT */
+ JVMDI_breakpoint_event_data breakpoint;
+
+ /* kind = JVMDI_EVENT_FRAME_POP */
+ /* kind = JVMDI_EVENT_METHOD_ENTRY */
+ /* kind = JVMDI_EVENT_METHOD_EXIT */
+ JVMDI_frame_event_data frame;
+
+ /* kind = JVMDI_EVENT_FIELD_ACCESS */
+ JVMDI_field_access_event_data field_access;
+
+ /* kind = JVMDI_EVENT_FIELD_MODIFICATION */
+ JVMDI_field_modification_event_data field_modification;
+
+ /* kind = JVMDI_EVENT_EXCEPTION */
+ JVMDI_exception_event_data exception;
+
+ /* kind = JVMDI_EVENT_EXCEPTION_CATCH */
+ JVMDI_exception_catch_event_data exception_catch;
+
+ /* kind = JVMDI_EVENT_USER_DEFINED */
+ JVMDI_user_event_data user;
+
+ /* kind = JVMDI_EVENT_THREAD_END or */
+ /* JVMDI_EVENT_THREAD_START */
+ JVMDI_thread_change_event_data thread_change;
+
+ /* kind = JVMDI_EVENT_CLASS_LOAD, */
+ /* JVMDI_EVENT_CLASS_UNLOAD, or */
+ /* JVMDI_EVENT_CLASS_PREPARE */
+ JVMDI_class_event_data class_event;
+
+ /* kind = JVMDI_EVENT_VM_DEATH, JVMDI_EVENT_VM_INIT */
+ /* no additional fields */
+ } u;
+} JVMDI_Event;
+
+ /*** event kinds ***/
+#define JVMDI_EVENT_SINGLE_STEP ((jint)1)
+#define JVMDI_EVENT_BREAKPOINT ((jint)2)
+#define JVMDI_EVENT_FRAME_POP ((jint)3)
+#define JVMDI_EVENT_EXCEPTION ((jint)4)
+#define JVMDI_EVENT_USER_DEFINED ((jint)5)
+#define JVMDI_EVENT_THREAD_START ((jint)6)
+#define JVMDI_EVENT_THREAD_END ((jint)7)
+#define JVMDI_EVENT_CLASS_PREPARE ((jint)8)
+#define JVMDI_EVENT_CLASS_UNLOAD ((jint)9)
+#define JVMDI_EVENT_CLASS_LOAD ((jint)10)
+#define JVMDI_EVENT_FIELD_ACCESS ((jint)20)
+#define JVMDI_EVENT_FIELD_MODIFICATION ((jint)21)
+#define JVMDI_EVENT_EXCEPTION_CATCH ((jint)30)
+#define JVMDI_EVENT_METHOD_ENTRY ((jint)40)
+#define JVMDI_EVENT_METHOD_EXIT ((jint)41)
+#define JVMDI_EVENT_VM_INIT ((jint)90)
+#define JVMDI_EVENT_VM_DEATH ((jint)99)
+
+#define JVMDI_MAX_EVENT_TYPE_VAL ((jint)99)
+
+
+
+/* event handler hook */
+typedef void (*JVMDI_EventHook)(JNIEnv *env, JVMDI_Event *event);
+
+typedef jvmdiError (*JVMDI_AllocHook) (jlong size, jbyte** memPtr);
+typedef jvmdiError (*JVMDI_DeallocHook) (jbyte* buffer);
+
+/*
+ * Class states used in JVMDI_GetClassStatus
+ */
+#define JVMDI_CLASS_STATUS_VERIFIED ((jint)0x01)
+#define JVMDI_CLASS_STATUS_PREPARED ((jint)0x02)
+#define JVMDI_CLASS_STATUS_INITIALIZED ((jint)0x04)
+ /* Error prevents initialization */
+#define JVMDI_CLASS_STATUS_ERROR ((jint)0x08)
+
+/* structure for returning line number information
+ */
+typedef struct {
+ jlocation start_location;
+ jint line_number;
+} JVMDI_line_number_entry;
+
+
+/* structure for returning local variable information
+ */
+typedef struct {
+ jlocation start_location; /* variable valid start_location */
+ jint length; /* upto start_location+length */
+ char *name; /* name in UTF8 */
+ char *signature; /* type signature in UTF8 */
+ jint slot; /* variable slot, see JVMDI_GetLocal*() */
+} JVMDI_local_variable_entry;
+
+/* structure for returning exception handler information
+ */
+typedef struct {
+ jlocation start_location;
+ jlocation end_location;
+ jlocation handler_location;
+ jclass exception; /* if null, all exceptions */
+} JVMDI_exception_handler_entry;
+
+#define JVMDI_OPERAND_TYPE_REFERENCE ((jint)1)
+#define JVMDI_OPERAND_TYPE_INT ((jint)2)
+#define JVMDI_OPERAND_TYPE_FLOAT ((jint)3)
+#define JVMDI_OPERAND_TYPE_LONG0 ((jint)4) /* least sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_LONG1 ((jint)5) /* most sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_DOUBLE0 ((jint)6) /* least sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_DOUBLE1 ((jint)7) /* most sig. 32 bits */
+#define JVMDI_OPERAND_TYPE_RETURN_ADDRESS ((jint)8)
+
+typedef struct {
+ jint word; /* 32 bit operand stack quantities */
+ jint type; /* type encoding of the operand word */
+ /* one of JVMDI_OPERAND_TYPE_* */
+} JVMDI_operand_stack_element;
+
+typedef struct {
+ jint instance_field_count; /* number of instance fields referencing obj */
+ struct JVMDI_instance_field {
+ jobject instance; /* instance referencing obj */
+ jfieldID field; /* field holding reference */
+ } *instance_fields; /* instanceField_count of them */
+
+ jint static_field_count; /* number of static fields referencing obj */
+ struct JVMDI_static_field {
+ jclass clazz; /* class referencing obj */
+ jfieldID static_field; /* field holding reference */
+ } *static_fields; /* static_field_count of them */
+
+ jint array_element_count; /* number of array elements referencing obj */
+ struct JVMDI_array_element {
+ jobjectArray array; /* array referencing obj */
+ jint index; /* index holding reference */
+ } *array_elements; /* array_element_count of them */
+
+ jint frame_slot_count; /* number of frame slots referencing obj */
+ struct JVMDI_frame_slot {
+ jthread thread; /* thread of the frame */
+ jframeID frame; /* frame referencing obj */
+ jint slot; /* slot holding reference */
+ } *frame_slots; /* frame_slot_count of them */
+} JVMDI_object_reference_info;
+
+/* structure for defining a class
+*/
+typedef struct {
+ jclass clazz; /* Class object for this class */
+ jint class_byte_count; /* number of bytes defining class (below) */
+ jbyte *class_bytes; /* bytes defining class (in JVM spec */
+ /* Class File Format) */
+} JVMDI_class_definition;
+
+ /* For backwards compatibility */
+#define can_change_schema can_unrestrictedly_redefine_classes
+
+typedef struct {
+ unsigned int can_watch_field_modification : 1;
+ unsigned int can_watch_field_access : 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_get_heap_info : 1;
+ unsigned int can_get_operand_stack : 1;
+ unsigned int can_set_operand_stack : 1;
+ unsigned int can_pop_frame : 1;
+ unsigned int can_get_class_definition : 1;
+ unsigned int can_redefine_classes : 1;
+ unsigned int can_add_method : 1;
+ unsigned int can_unrestrictedly_redefine_classes : 1;
+ unsigned int can_suspend_resume_thread_lists : 1;
+} JVMDI_capabilities;
+
+typedef struct JVMDI_Interface_1_ {
+ jvmdiError (JNICALL *SetEventHook)
+ (JVMDI_EventHook hook);
+ jvmdiError (JNICALL *SetEventNotificationMode)
+ (jint mode, jint eventType, jthread thread, ...);
+
+ jvmdiError (JNICALL *GetThreadStatus)
+ (jthread thread,
+ jint *threadStatusPtr, jint *suspendStatusPtr);
+ jvmdiError (JNICALL *GetAllThreads)
+ (jint *threadsCountPtr, jthread **threadsPtr);
+ jvmdiError (JNICALL *SuspendThread)
+ (jthread thread);
+ jvmdiError (JNICALL *ResumeThread)
+ (jthread thread);
+ jvmdiError (JNICALL *StopThread)
+ (jthread thread, jobject exception);
+ jvmdiError (JNICALL *InterruptThread)
+ (jthread thread);
+ jvmdiError (JNICALL *GetThreadInfo)
+ (jthread thread, JVMDI_thread_info *infoPtr);
+ jvmdiError (JNICALL *GetOwnedMonitorInfo)
+ (jthread thread, JVMDI_owned_monitor_info *infoPtr);
+ jvmdiError (JNICALL *GetCurrentContendedMonitor)
+ (jthread thread, jobject *monitor);
+ jvmdiError (JNICALL *RunDebugThread)
+ (jthread thread, JVMDI_StartFunction proc, void *arg,
+ int priority);
+
+ jvmdiError (JNICALL *GetTopThreadGroups)
+ (jint *groupCountPtr, jthreadGroup **groupsPtr);
+ jvmdiError (JNICALL *GetThreadGroupInfo)
+ (jthreadGroup group, JVMDI_thread_group_info *infoPtr);
+ jvmdiError (JNICALL *GetThreadGroupChildren)
+ (jthreadGroup group,
+ jint *threadCountPtr, jthread **threadsPtr,
+ jint *groupCountPtr, jthreadGroup **groupsPtr);
+
+ jvmdiError (JNICALL *GetFrameCount)
+ (jthread thread, jint *countPtr);
+ jvmdiError (JNICALL *GetCurrentFrame)
+ (jthread thread, jframeID *framePtr);
+ jvmdiError (JNICALL *GetCallerFrame)
+ (jframeID called, jframeID *framePtr);
+ jvmdiError (JNICALL *GetFrameLocation)
+ (jframeID frame, jclass *classPtr, jmethodID *methodPtr,
+ jlocation *locationPtr);
+ jvmdiError (JNICALL *NotifyFramePop)
+ (jframeID frame);
+ jvmdiError (JNICALL *GetLocalObject)
+ (jframeID frame, jint slot, jobject *valuePtr);
+ jvmdiError (JNICALL *GetLocalInt)
+ (jframeID frame, jint slot, jint *valuePtr);
+ jvmdiError (JNICALL *GetLocalLong)
+ (jframeID frame, jint slot, jlong *valuePtr);
+ jvmdiError (JNICALL *GetLocalFloat)
+ (jframeID frame, jint slot, jfloat *valuePtr);
+ jvmdiError (JNICALL *GetLocalDouble)
+ (jframeID frame, jint slot, jdouble *valuePtr);
+ jvmdiError (JNICALL *SetLocalObject)
+ (jframeID frame, jint slot, jobject value);
+ jvmdiError (JNICALL *SetLocalInt)
+ (jframeID frame, jint slot, jint value);
+ jvmdiError (JNICALL *SetLocalLong)
+ (jframeID frame, jint slot, jlong value);
+ jvmdiError (JNICALL *SetLocalFloat)
+ (jframeID frame, jint slot, jfloat value);
+ jvmdiError (JNICALL *SetLocalDouble)
+ (jframeID frame, jint slot, jdouble value);
+
+ jvmdiError (JNICALL *CreateRawMonitor)
+ (char *name, JVMDI_RawMonitor *monitorPtr);
+ jvmdiError (JNICALL *DestroyRawMonitor)
+ (JVMDI_RawMonitor monitor);
+ jvmdiError (JNICALL *RawMonitorEnter)
+ (JVMDI_RawMonitor monitor);
+ jvmdiError (JNICALL *RawMonitorExit)
+ (JVMDI_RawMonitor monitor);
+ jvmdiError (JNICALL *RawMonitorWait)
+ (JVMDI_RawMonitor monitor, jlong millis);
+ jvmdiError (JNICALL *RawMonitorNotify)
+ (JVMDI_RawMonitor monitor);
+ jvmdiError (JNICALL *RawMonitorNotifyAll)
+ (JVMDI_RawMonitor monitor);
+
+ jvmdiError (JNICALL *SetBreakpoint)
+ (jclass clazz, jmethodID method, jlocation location);
+ jvmdiError (JNICALL *ClearBreakpoint)
+ (jclass clazz, jmethodID method, jlocation location);
+ jvmdiError (JNICALL *ClearAllBreakpoints)
+ ();
+
+ jvmdiError (JNICALL *SetFieldAccessWatch)
+ (jclass clazz, jfieldID field);
+ jvmdiError (JNICALL *ClearFieldAccessWatch)
+ (jclass clazz, jfieldID field);
+ jvmdiError (JNICALL *SetFieldModificationWatch)
+ (jclass clazz, jfieldID field);
+ jvmdiError (JNICALL *ClearFieldModificationWatch)
+ (jclass clazz, jfieldID field);
+
+ jvmdiError (JNICALL *SetAllocationHooks)
+ (JVMDI_AllocHook ahook, JVMDI_DeallocHook dhook);
+ jvmdiError (JNICALL *Allocate)
+ (jlong size, jbyte** memPtr);
+ jvmdiError (JNICALL *Deallocate)
+ (jbyte* mem);
+
+ jvmdiError (JNICALL *GetClassSignature)
+ (jclass clazz, char **sigPtr);
+ jvmdiError (JNICALL *GetClassStatus)
+ (jclass clazz, jint *statusPtr);
+ jvmdiError (JNICALL *GetSourceFileName)
+ (jclass clazz, char **sourceNamePtr);
+ jvmdiError (JNICALL *GetClassModifiers)
+ (jclass clazz, jint *modifiersPtr);
+ jvmdiError (JNICALL *GetClassMethods)
+ (jclass clazz, jint *methodCountPtr, jmethodID **methodsPtr);
+ jvmdiError (JNICALL *GetClassFields)
+ (jclass clazz, jint *fieldCountPtr, jfieldID **fieldsPtr);
+ jvmdiError (JNICALL *GetImplementedInterfaces)
+ (jclass clazz, jint *interfaceCountPtr, jclass **interfacesPtr);
+ jvmdiError (JNICALL *IsInterface)
+ (jclass clazz, jboolean *isInterfacePtr);
+ jvmdiError (JNICALL *IsArrayClass)
+ (jclass clazz, jboolean *isArrayClassPtr);
+ jvmdiError (JNICALL *GetClassLoader)
+ (jclass clazz, jobject *classloaderPtr);
+
+ jvmdiError (JNICALL *GetObjectHashCode)
+ (jobject object, jint *hashCodePtr);
+ jvmdiError (JNICALL *GetMonitorInfo)
+ (jobject object, JVMDI_monitor_info *infoPtr);
+
+ jvmdiError (JNICALL *GetFieldName)
+ (jclass clazz, jfieldID field, char **namePtr, char **signaturePtr);
+ jvmdiError (JNICALL *GetFieldDeclaringClass)
+ (jclass clazz, jfieldID field, jclass *declaringClassPtr);
+ jvmdiError (JNICALL *GetFieldModifiers)
+ (jclass clazz, jfieldID field, jint *modifiersPtr);
+ jvmdiError (JNICALL *IsFieldSynthetic)
+ (jclass clazz, jfieldID field, jboolean *isSyntheticPtr);
+
+ jvmdiError (JNICALL *GetMethodName)
+ (jclass clazz, jmethodID method,
+ char **namePtr, char **signaturePtr);
+ jvmdiError (JNICALL *GetMethodDeclaringClass)
+ (jclass clazz, jmethodID method, jclass *declaringClassPtr);
+ jvmdiError (JNICALL *GetMethodModifiers)
+ (jclass clazz, jmethodID method, jint *modifiersPtr);
+ jvmdiError (JNICALL *GetMaxStack)
+ (jclass clazz, jmethodID method, jint *maxPtr);
+ jvmdiError (JNICALL *GetMaxLocals)
+ (jclass clazz, jmethodID method, jint *maxPtr);
+ jvmdiError (JNICALL *GetArgumentsSize)
+ (jclass clazz, jmethodID method, jint *sizePtr);
+ jvmdiError (JNICALL *GetLineNumberTable)
+ (jclass clazz, jmethodID method,
+ jint *entryCountPtr, JVMDI_line_number_entry **tablePtr);
+ jvmdiError (JNICALL *GetMethodLocation)
+ (jclass clazz, jmethodID method,
+ jlocation *startLocationPtr, jlocation *endLocationPtr);
+ jvmdiError (JNICALL *GetLocalVariableTable)
+ (jclass clazz, jmethodID method,
+ jint *entryCountPtr, JVMDI_local_variable_entry **tablePtr);
+ jvmdiError (JNICALL *GetExceptionHandlerTable)
+ (jclass clazz, jmethodID method,
+ jint *entryCountPtr, JVMDI_exception_handler_entry **tablePtr);
+ jvmdiError (JNICALL *GetThrownExceptions)
+ (jclass clazz, jmethodID method,
+ jint *exceptionCountPtr, jclass **exceptionsPtr);
+ jvmdiError (JNICALL *GetBytecodes)
+ (jclass clazz, jmethodID method,
+ jint *bytecodeCountPtr, jbyte **bytecodesPtr);
+ jvmdiError (JNICALL *IsMethodNative)
+ (jclass clazz, jmethodID method, jboolean *isNativePtr);
+ jvmdiError (JNICALL *IsMethodSynthetic)
+ (jclass clazz, jmethodID method, jboolean *isSyntheticPtr);
+
+ jvmdiError (JNICALL *GetLoadedClasses)
+ (jint *classCountPtr, jclass **classesPtr);
+ jvmdiError (JNICALL *GetClassLoaderClasses)
+ (jobject initiatingLoader, jint *classesCountPtr,
+ jclass **classesPtr);
+
+ jvmdiError (JNICALL *PopFrame)
+ (jthread thread);
+ jvmdiError (JNICALL *SetFrameLocation)
+ (jframeID frame, jlocation location);
+ jvmdiError (JNICALL *GetOperandStack)
+ (jframeID frame, jint *operandStackSizePtr,
+ JVMDI_operand_stack_element **operandStackPtr);
+ jvmdiError (JNICALL *SetOperandStack)
+ (jframeID frame, jint operandStackSize,
+ JVMDI_operand_stack_element *operandStack);
+ jvmdiError (JNICALL *AllInstances)
+ (jclass clazz, jint *instanceCountPtr, jobject **instancesPtr);
+ jvmdiError (JNICALL *References)
+ (jobject obj, JVMDI_object_reference_info *refs);
+ jvmdiError (JNICALL *GetClassDefinition)
+ (jclass clazz, JVMDI_class_definition *classDefPtr);
+ jvmdiError (JNICALL *RedefineClasses)
+ (jint classCount, JVMDI_class_definition *classDefs);
+
+ jvmdiError (JNICALL *GetVersionNumber)
+ (jint *versionPtr);
+ jvmdiError (JNICALL *GetCapabilities)
+ (JVMDI_capabilities *capabilitiesPtr);
+
+ jvmdiError (JNICALL *GetSourceDebugExtension)
+ (jclass clazz, char **sourceDebugExtension);
+ jvmdiError (JNICALL *IsMethodObsolete)
+ (jclass clazz, jmethodID method, jboolean *isObsoletePtr);
+
+ jvmdiError (JNICALL *SuspendThreadList)
+ (jint reqCount, jthread *reqList, jvmdiError *results);
+ jvmdiError (JNICALL *ResumeThreadList)
+ (jint reqCount, jthread *reqList, jvmdiError *results);
+} JVMDI_Interface_1;
+
+#ifndef NO_JVMDI_MACROS
+
+#define JVMDI_ERROR_DUPLICATE_BREAKPOINT JVMDI_ERROR_DUPLICATE
+#define JVMDI_ERROR_NO_SUCH_BREAKPOINT JVMDI_ERROR_NOT_FOUND
+#define JVMDI_ERROR_DUPLICATE_FRAME_POP JVMDI_ERROR_DUPLICATE
+
+
+static JVMDI_Interface_1 *jvmdi_interface = NULL;
+static JavaVM *j_vm;
+
+#ifdef __cplusplus
+#define SetJVMDIfromJNIEnv(a_env) ( (jvmdi_interface == NULL)? \
+ ((a_env)->GetJavaVM(&j_vm), \
+ (j_vm)->GetEnv((void **)&jvmdi_interface, \
+ JVMDI_VERSION_1)):0)
+#else
+#define SetJVMDIfromJNIEnv(a_env) ( (jvmdi_interface == NULL)? \
+ ((*a_env)->GetJavaVM(a_env, &j_vm), \
+ (*j_vm)->GetEnv(j_vm, (void **)&jvmdi_interface, \
+ JVMDI_VERSION_1)):0)
+#endif
+
+#define JVMDI_SetEventHook(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetEventHook(a1) )
+#define JVMDI_GetThreadStatus(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetThreadStatus(a1, a2, a3) )
+#define JVMDI_GetAllThreads(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetAllThreads(a1, a2) )
+#define JVMDI_SuspendThread(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SuspendThread(a1) )
+#define JVMDI_ResumeThread(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->ResumeThread(a1) )
+#define JVMDI_StopThread(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->StopThread(a1, a2) )
+#define JVMDI_InterruptThread(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->InterruptThread(a1) )
+#define JVMDI_SetSingleStep(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetEventNotificationMode( \
+ (a2) ? JVMDI_ENABLE : JVMDI_DISABLE, \
+ JVMDI_EVENT_SINGLE_STEP, a1) )
+#define JVMDI_GetThreadInfo(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetThreadInfo(a1, a2) )
+#define JVMDI_RunDebugThread(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RunDebugThread(a1, a2, a3, a4) )
+#define JVMDI_GetTopThreadGroups(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetTopThreadGroups(a1, a2) )
+#define JVMDI_GetThreadGroupInfo(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetThreadGroupInfo(a1, a2) )
+#define JVMDI_GetThreadGroupChildren(a_env, a1, a2, a3, a4, a5) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetThreadGroupChildren(a1, a2, a3, a4, a5) )
+#define JVMDI_GetCurrentFrame(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetCurrentFrame(a1, a2) )
+#define JVMDI_GetCallerFrame(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetCallerFrame(a1, a2) )
+#define JVMDI_GetFrameLocation(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetFrameLocation(a1, a2, a3, a4) )
+#define JVMDI_NotifyFramePop(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->NotifyFramePop(a1) )
+#define JVMDI_GetLocalObject(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalObject(a1, a2, a3) )
+#define JVMDI_GetLocalInt(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalInt(a1, a2, a3) )
+#define JVMDI_GetLocalLong(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalLong(a1, a2, a3) )
+#define JVMDI_GetLocalFloat(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalFloat(a1, a2, a3) )
+#define JVMDI_GetLocalDouble(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalDouble(a1, a2, a3) )
+#define JVMDI_SetLocalObject(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetLocalObject(a1, a2, a3) )
+#define JVMDI_SetLocalInt(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetLocalInt(a1, a2, a3) )
+#define JVMDI_SetLocalLong(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetLocalLong(a1, a2, a3) )
+#define JVMDI_SetLocalFloat(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetLocalFloat(a1, a2, a3) )
+#define JVMDI_SetLocalDouble(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetLocalDouble(a1, a2, a3) )
+#define JVMDI_CreateRawMonitor(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->CreateRawMonitor(a1, a2) )
+#define JVMDI_DestroyRawMonitor(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->DestroyRawMonitor(a1) )
+#define JVMDI_RawMonitorEnter(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RawMonitorEnter(a1) )
+#define JVMDI_RawMonitorExit(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RawMonitorExit(a1) )
+#define JVMDI_RawMonitorWait(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RawMonitorWait(a1, a2) )
+#define JVMDI_RawMonitorNotify(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RawMonitorNotify(a1) )
+#define JVMDI_RawMonitorNotifyAll(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->RawMonitorNotifyAll(a1) )
+#define JVMDI_SetBreakpoint(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetBreakpoint(a1, a2, a3) )
+#define JVMDI_ClearBreakpoint(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->ClearBreakpoint(a1, a2, a3) )
+#define JVMDI_ClearAllBreakpoints(a_env) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->ClearAllBreakpoints() )
+#define JVMDI_SetAllocationHooks(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->SetAllocationHooks(a1, a2) )
+#define JVMDI_Allocate(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->Allocate(a1, a2) )
+#define JVMDI_Deallocate(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->Deallocate(a1) )
+#define JVMDI_GetClassSignature(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassSignature(a1, a2) )
+#define JVMDI_GetClassStatus(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassStatus(a1, a2) )
+#define JVMDI_GetSourceFileName(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetSourceFileName(a1, a2) )
+#define JVMDI_GetClassModifiers(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassModifiers(a1, a2) )
+#define JVMDI_GetClassMethods(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassMethods(a1, a2, a3) )
+#define JVMDI_GetClassFields(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassFields(a1, a2, a3) )
+#define JVMDI_GetImplementedInterfaces(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetImplementedInterfaces(a1, a2, a3) )
+#define JVMDI_IsInterface(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->IsInterface(a1, a2) )
+#define JVMDI_IsArrayClass(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->IsArrayClass(a1, a2) )
+#define JVMDI_ClassLoader(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassLoader(a1, a2) )
+#define JVMDI_GetFieldName(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetFieldName(a1, a2, a3, a4) )
+#define JVMDI_GetFieldDeclaringClass(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetFieldDeclaringClass(a1, a2, a3) )
+#define JVMDI_GetFieldModifiers(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetFieldModifiers(a1, a2, a3) )
+#define JVMDI_GetMethodName(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMethodName(a1, a2, a3, a4) )
+#define JVMDI_GetMethodDeclaringClass(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMethodDeclaringClass(a1, a2, a3) )
+#define JVMDI_GetMethodModifiers(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMethodModifiers(a1, a2, a3) )
+#define JVMDI_GetMaxStack(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMaxStack(a1, a2, a3) )
+#define JVMDI_GetMaxLocals(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMaxLocals(a1, a2, a3) )
+#define JVMDI_GetArgumentsSize(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetArgumentsSize(a1, a2, a3) )
+#define JVMDI_GetLineNumberTable(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLineNumberTable(a1, a2, a3, a4) )
+#define JVMDI_GetMethodLocation(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetMethodLocation(a1, a2, a3, a4) )
+#define JVMDI_GetLocalVariableTable(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLocalVariableTable(a1, a2, a3, a4) )
+#define JVMDI_GetExceptionHandlerTable(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetExceptionHandlerTable(a1, a2, a3, a4) )
+#define JVMDI_GetThrownExceptions(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetThrownExceptions(a1, a2, a3, a4) )
+#define JVMDI_GetBytecodes(a_env, a1, a2, a3, a4) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetBytecodes(a1, a2, a3, a4) )
+#define JVMDI_IsMethodNative(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->IsMethodNative(a1, a2, a3) )
+#define JVMDI_GetLoadedClasses(a_env, a1, a2) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetLoadedClasses(a1, a2) )
+#define JVMDI_GetClassLoaderClasses(a_env, a1, a2, a3) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetClassLoaderClasses(a1, a2, a3) )
+#define JVMDI_GetVersionNumber(a_env, a1) ( \
+ SetJVMDIfromJNIEnv(a_env), \
+ jvmdi_interface->GetVersionNumber(a1) )
+
+#endif /* !NO_JVMDI_MACROS */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* !_JAVASOFT_JVMDI_H_ */
+
+
diff --git a/make/stub_includes/jni/macosx/jvmpi.h b/make/stub_includes/jni/macosx/jvmpi.h
new file mode 100644
index 000000000..2dbaae5e7
--- /dev/null
+++ b/make/stub_includes/jni/macosx/jvmpi.h
@@ -0,0 +1,642 @@
+/*
+ * @(#)jvmpi.h 1.28 03/12/19
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JVMPI_H_
+#define _JAVASOFT_JVMPI_H_
+
+#include "jni.h"
+
+#define JVMPI_VERSION_1 ((jint)0x10000001) /* implied 0 for minor version */
+#define JVMPI_VERSION_1_1 ((jint)0x10000002)
+#define JVMPI_VERSION_1_2 ((jint)0x10000003)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ typedef void (*jvmpi_void_function_of_void)(void *);
+#ifdef __cplusplus
+}
+#endif
+
+/****************************************************************
+ * Profiler interface data structures.
+ ****************************************************************/
+/* identifier types. */
+struct _jobjectID;
+typedef struct _jobjectID * jobjectID; /* type of object ids */
+
+/* raw monitors */
+struct _JVMPI_RawMonitor;
+typedef struct _JVMPI_RawMonitor * JVMPI_RawMonitor;
+
+/* call frame */
+typedef struct {
+ jint lineno; /* line number in the source file */
+ jmethodID method_id; /* method executed in this frame */
+} JVMPI_CallFrame;
+
+/* call trace */
+typedef struct {
+ JNIEnv *env_id; /* Env where trace was recorded */
+ jint num_frames; /* number of frames in this trace */
+ JVMPI_CallFrame *frames; /* frames */
+} JVMPI_CallTrace;
+
+/* method */
+typedef struct {
+ char *method_name; /* name of method */
+ char *method_signature; /* signature of method */
+ jint start_lineno; /* -1 if native, abstract .. */
+ jint end_lineno; /* -1 if native, abstract .. */
+ jmethodID method_id; /* id assigned to this method */
+} JVMPI_Method;
+
+/* Field */
+typedef struct {
+ char *field_name; /* name of field */
+ char *field_signature; /* signature of field */
+} JVMPI_Field;
+
+/* line number info for a compiled method */
+typedef struct {
+ jint offset; /* offset from beginning of method */
+ jint lineno; /* lineno from beginning of src file */
+} JVMPI_Lineno;
+
+/* event */
+typedef struct {
+ jint event_type; /* event_type */
+ JNIEnv *env_id; /* env where this event occured */
+
+ union {
+ struct {
+ const char *class_name; /* class name */
+ char *source_name; /* name of source file */
+ jint num_interfaces; /* number of interfaces implemented */
+ jint num_methods; /* number of methods in the class */
+ JVMPI_Method *methods; /* methods */
+ jint num_static_fields; /* number of static fields */
+ JVMPI_Field *statics; /* static fields */
+ jint num_instance_fields; /* number of instance fields */
+ JVMPI_Field *instances; /* instance fields */
+ jobjectID class_id; /* id of the class object */
+ } class_load;
+
+ struct {
+ jobjectID class_id; /* id of the class object */
+ } class_unload;
+
+ struct {
+ unsigned char *class_data; /* content of class file */
+ jint class_data_len; /* class file length */
+ unsigned char *new_class_data; /* instrumented class file */
+ jint new_class_data_len; /* new class file length */
+ void * (*malloc_f)(unsigned int); /* memory allocation function */
+ } class_load_hook;
+
+ struct {
+ jint arena_id;
+ jobjectID class_id; /* id of object class */
+ jint is_array; /* JVMPI_NORMAL_OBJECT, ... */
+ jint size; /* size in number of bytes */
+ jobjectID obj_id; /* id assigned to this object */
+ } obj_alloc;
+
+ struct {
+ jobjectID obj_id; /* id of the object */
+ } obj_free;
+
+ struct {
+ jint arena_id; /* cur arena id */
+ jobjectID obj_id; /* cur object id */
+ jint new_arena_id; /* new arena id */
+ jobjectID new_obj_id; /* new object id */
+ } obj_move;
+
+ struct {
+ jint arena_id; /* id of arena */
+ const char *arena_name; /* name of arena */
+ } new_arena;
+
+ struct {
+ jint arena_id; /* id of arena */
+ } delete_arena;
+
+ struct {
+ char *thread_name; /* name of thread */
+ char *group_name; /* name of group */
+ char *parent_name; /* name of parent */
+ jobjectID thread_id; /* id of the thread object */
+ JNIEnv *thread_env_id;
+ } thread_start;
+
+ struct {
+ int dump_level; /* level of the heap dump info */
+ char *begin; /* where all the root records begin,
+ please see the heap dump buffer
+ format described below */
+ char *end; /* where the object records end. */
+ jint num_traces; /* number of thread traces,
+ 0 if dump level = JVMPI_DUMP_LEVEL_0 */
+ JVMPI_CallTrace *traces; /* thread traces collected during
+ heap dump */
+ } heap_dump;
+
+ struct {
+ jobjectID obj_id; /* object id */
+ jobject ref_id; /* id assigned to the globalref */
+ } jni_globalref_alloc;
+
+ struct {
+ jobject ref_id; /* id of the global ref */
+ } jni_globalref_free;
+
+ struct {
+ jmethodID method_id; /* method */
+ } method;
+
+ struct {
+ jmethodID method_id; /* id of method */
+ jobjectID obj_id; /* id of target object */
+ } method_entry2;
+
+ struct {
+ jmethodID method_id; /* id of compiled method */
+ void *code_addr; /* code start addr. in memory */
+ jint code_size; /* code size */
+ jint lineno_table_size; /* size of lineno table */
+ JVMPI_Lineno *lineno_table; /* lineno info */
+ } compiled_method_load;
+
+ struct {
+ jmethodID method_id; /* id of unloaded compiled method */
+ } compiled_method_unload;
+
+ struct {
+ jmethodID method_id; /* id of the method the instruction belongs to */
+ jint offset; /* instruction offset in the method's bytecode */
+ union {
+ struct {
+ jboolean is_true; /* whether true or false branch is taken */
+ } if_info;
+ struct {
+ jint key; /* top stack value used as an index */
+ jint low; /* min value of the index */
+ jint hi; /* max value of the index */
+ } tableswitch_info;
+ struct {
+ jint chosen_pair_index; /* actually chosen pair index (0-based)
+ * if chosen_pair_index == pairs_total then
+ * the 'default' branch is taken
+ */
+ jint pairs_total; /* total number of lookupswitch pairs */
+ } lookupswitch_info;
+ } u;
+ } instruction;
+
+ struct {
+ char *begin; /* beginning of dump buffer,
+ see below for format */
+ char *end; /* end of dump buffer */
+ jint num_traces; /* number of traces */
+ JVMPI_CallTrace *traces; /* traces of all threads */
+ jint *threads_status; /* status of all threads */
+ } monitor_dump;
+
+ struct {
+ const char *name; /* name of raw monitor */
+ JVMPI_RawMonitor id; /* id */
+ } raw_monitor;
+
+ struct {
+ jobjectID object; /* Java object */
+ } monitor;
+
+ struct {
+ jobjectID object; /* Java object */
+ jlong timeout; /* timeout period */
+ } monitor_wait;
+
+ struct {
+ jlong used_objects;
+ jlong used_object_space;
+ jlong total_object_space;
+ } gc_info;
+
+ struct {
+ jint data_len;
+ char *data;
+ } object_dump;
+ } u;
+} JVMPI_Event;
+
+/* interface functions */
+typedef struct {
+ jint version; /* JVMPI version */
+
+ /* ------interface implemented by the profiler------ */
+
+ /**
+ * Function called by the JVM to notify an event.
+ */
+ void (*NotifyEvent)(JVMPI_Event *event);
+
+ /* ------interface implemented by the JVM------ */
+
+ /**
+ * Function called by the profiler to enable/disable/send notification
+ * for a particular event type.
+ *
+ * event_type - event_type
+ * arg - event specific arg
+ *
+ * return JVMPI_NOT_AVAILABLE, JVMPI_SUCCESS or JVMPI_FAIL
+ */
+ jint (*EnableEvent)(jint event_type, void *arg);
+ jint (*DisableEvent)(jint event_type, void *arg);
+ jint (*RequestEvent)(jint event_type, void *arg);
+
+ /**
+ * Function called by the profiler to get a stack
+ * trace from the JVM.
+ *
+ * trace - trace data structure to be filled
+ * depth - maximum depth of the trace.
+ */
+ void (*GetCallTrace)(JVMPI_CallTrace *trace, jint depth);
+
+ /**
+ * Function called by profiler when it wants to exit/stop.
+ */
+ void (*ProfilerExit)(jint);
+
+ /**
+ * Utility functions provided by the JVM.
+ */
+ JVMPI_RawMonitor (*RawMonitorCreate)(char *lock_name);
+ void (*RawMonitorEnter)(JVMPI_RawMonitor lock_id);
+ void (*RawMonitorExit)(JVMPI_RawMonitor lock_id);
+ void (*RawMonitorWait)(JVMPI_RawMonitor lock_id, jlong ms);
+ void (*RawMonitorNotifyAll)(JVMPI_RawMonitor lock_id);
+ void (*RawMonitorDestroy)(JVMPI_RawMonitor lock_id);
+
+ /**
+ * Function called by the profiler to get the current thread's CPU time.
+ *
+ * return time in nanoseconds;
+ */
+ jlong (*GetCurrentThreadCpuTime)(void);
+
+ void (*SuspendThread)(JNIEnv *env);
+ void (*ResumeThread)(JNIEnv *env);
+ jint (*GetThreadStatus)(JNIEnv *env);
+ jboolean (*ThreadHasRun)(JNIEnv *env);
+
+ /* This function can be called safely only after JVMPI_EVENT_VM_INIT_DONE
+ notification by the JVM. */
+ jint (*CreateSystemThread)(char *name, jint priority, void (*f)(void *));
+
+ /* thread local storage access functions to avoid locking in time
+ critical functions */
+ void (*SetThreadLocalStorage)(JNIEnv *env_id, void *ptr);
+ void * (*GetThreadLocalStorage)(JNIEnv *env_id);
+
+ /* control GC */
+ void (*DisableGC)(void);
+ void (*EnableGC)(void);
+ void (*RunGC)(void);
+
+ jobjectID (*GetThreadObject)(JNIEnv *env);
+ jobjectID (*GetMethodClass)(jmethodID mid);
+
+ /* JNI <-> jobject conversions */
+ jobject (*jobjectID2jobject)(jobjectID jid);
+ jobjectID (*jobject2jobjectID)(jobject jobj);
+
+ void (*SuspendThreadList)
+ (jint reqCount, JNIEnv **reqList, jint *results);
+ void (*ResumeThreadList)
+ (jint reqCount, JNIEnv **reqList, jint *results);
+} JVMPI_Interface;
+
+/* type of argument passed to RequestEvent for heap dumps */
+typedef struct {
+ jint heap_dump_level;
+} JVMPI_HeapDumpArg;
+
+/**********************************************************************
+ * Constants and formats used in JVM Profiler Interface.
+ **********************************************************************/
+/*
+ * Event type constants.
+ */
+#define JVMPI_EVENT_METHOD_ENTRY ((jint)1)
+#define JVMPI_EVENT_METHOD_ENTRY2 ((jint)2)
+#define JVMPI_EVENT_METHOD_EXIT ((jint)3)
+
+#define JVMPI_EVENT_OBJECT_ALLOC ((jint)4)
+#define JVMPI_EVENT_OBJECT_FREE ((jint)5)
+#define JVMPI_EVENT_OBJECT_MOVE ((jint)6)
+
+#define JVMPI_EVENT_COMPILED_METHOD_LOAD ((jint)7)
+#define JVMPI_EVENT_COMPILED_METHOD_UNLOAD ((jint)8)
+
+#define JVMPI_EVENT_INSTRUCTION_START ((jint)9)
+
+#define JVMPI_EVENT_THREAD_START ((jint)33)
+#define JVMPI_EVENT_THREAD_END ((jint)34)
+
+#define JVMPI_EVENT_CLASS_LOAD_HOOK ((jint)35)
+
+#define JVMPI_EVENT_HEAP_DUMP ((jint)37)
+#define JVMPI_EVENT_JNI_GLOBALREF_ALLOC ((jint)38)
+#define JVMPI_EVENT_JNI_GLOBALREF_FREE ((jint)39)
+#define JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC ((jint)40)
+#define JVMPI_EVENT_JNI_WEAK_GLOBALREF_FREE ((jint)41)
+#define JVMPI_EVENT_CLASS_LOAD ((jint)42)
+#define JVMPI_EVENT_CLASS_UNLOAD ((jint)43)
+#define JVMPI_EVENT_DATA_DUMP_REQUEST ((jint)44)
+#define JVMPI_EVENT_DATA_RESET_REQUEST ((jint)45)
+
+#define JVMPI_EVENT_JVM_INIT_DONE ((jint)46)
+#define JVMPI_EVENT_JVM_SHUT_DOWN ((jint)47)
+
+#define JVMPI_EVENT_ARENA_NEW ((jint)48)
+#define JVMPI_EVENT_ARENA_DELETE ((jint)49)
+
+#define JVMPI_EVENT_OBJECT_DUMP ((jint)50)
+
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTER ((jint)51)
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTERED ((jint)52)
+#define JVMPI_EVENT_RAW_MONITOR_CONTENDED_EXIT ((jint)53)
+#define JVMPI_EVENT_MONITOR_CONTENDED_ENTER ((jint)54)
+#define JVMPI_EVENT_MONITOR_CONTENDED_ENTERED ((jint)55)
+#define JVMPI_EVENT_MONITOR_CONTENDED_EXIT ((jint)56)
+#define JVMPI_EVENT_MONITOR_WAIT ((jint)57)
+#define JVMPI_EVENT_MONITOR_WAITED ((jint)58)
+#define JVMPI_EVENT_MONITOR_DUMP ((jint)59)
+
+#define JVMPI_EVENT_GC_START ((jint)60)
+#define JVMPI_EVENT_GC_FINISH ((jint)61)
+
+#define JVMPI_MAX_EVENT_TYPE_VAL ((jint)61)
+
+/* old definitions, to be removed */
+#define JVMPI_EVENT_LOAD_COMPILED_METHOD ((jint)7)
+#define JVMPI_EVENT_UNLOAD_COMPILED_METHOD ((jint)8)
+#define JVMPI_EVENT_NEW_ARENA ((jint)48)
+#define JVMPI_EVENT_DELETE_ARENA ((jint)49)
+#define JVMPI_EVENT_DUMP_DATA_REQUEST ((jint)44)
+#define JVMPI_EVENT_RESET_DATA_REQUEST ((jint)45)
+#define JVMPI_EVENT_OBJ_ALLOC ((jint)4)
+#define JVMPI_EVENT_OBJ_FREE ((jint)5)
+#define JVMPI_EVENT_OBJ_MOVE ((jint)6)
+
+#define JVMPI_REQUESTED_EVENT ((jint)0x10000000)
+
+
+
+/*
+ * enabling/disabling event notification.
+ */
+/* results */
+#define JVMPI_SUCCESS ((jint)0)
+#define JVMPI_NOT_AVAILABLE ((jint)1)
+#define JVMPI_FAIL ((jint)-1)
+
+/*
+ * Thread status
+ */
+enum {
+ JVMPI_THREAD_RUNNABLE = 1,
+ JVMPI_THREAD_MONITOR_WAIT,
+ JVMPI_THREAD_CONDVAR_WAIT
+};
+
+#define JVMPI_THREAD_SUSPENDED 0x8000
+#define JVMPI_THREAD_INTERRUPTED 0x4000
+
+/*
+ * Thread priority
+ */
+#define JVMPI_MINIMUM_PRIORITY 1
+#define JVMPI_MAXIMUM_PRIORITY 10
+#define JVMPI_NORMAL_PRIORITY 5
+
+/*
+ * Object type constants.
+ */
+#define JVMPI_NORMAL_OBJECT ((jint)0)
+#define JVMPI_CLASS ((jint)2)
+#define JVMPI_BOOLEAN ((jint)4)
+#define JVMPI_CHAR ((jint)5)
+#define JVMPI_FLOAT ((jint)6)
+#define JVMPI_DOUBLE ((jint)7)
+#define JVMPI_BYTE ((jint)8)
+#define JVMPI_SHORT ((jint)9)
+#define JVMPI_INT ((jint)10)
+#define JVMPI_LONG ((jint)11)
+
+/*
+ * Monitor dump constants.
+ */
+
+#define JVMPI_MONITOR_JAVA 0x01
+#define JVMPI_MONITOR_RAW 0x02
+
+/*
+ * Heap dump constants.
+ */
+#define JVMPI_GC_ROOT_UNKNOWN 0xff
+#define JVMPI_GC_ROOT_JNI_GLOBAL 0x01
+#define JVMPI_GC_ROOT_JNI_LOCAL 0x02
+#define JVMPI_GC_ROOT_JAVA_FRAME 0x03
+#define JVMPI_GC_ROOT_NATIVE_STACK 0x04
+#define JVMPI_GC_ROOT_STICKY_CLASS 0x05
+#define JVMPI_GC_ROOT_THREAD_BLOCK 0x06
+#define JVMPI_GC_ROOT_MONITOR_USED 0x07
+#define JVMPI_GC_ROOT_THREAD_OBJ 0x08
+
+#define JVMPI_GC_CLASS_DUMP 0x20
+#define JVMPI_GC_INSTANCE_DUMP 0x21
+#define JVMPI_GC_OBJ_ARRAY_DUMP 0x22
+#define JVMPI_GC_PRIM_ARRAY_DUMP 0x23
+
+/*
+ * Dump levels
+ */
+#define JVMPI_DUMP_LEVEL_0 ((jint)0)
+#define JVMPI_DUMP_LEVEL_1 ((jint)1)
+#define JVMPI_DUMP_LEVEL_2 ((jint)2)
+
+/* Types used in dumps -
+ *
+ * u1: 1 byte
+ * u2: 2 bytes
+ * u4: 4 bytes
+ * u8: 8 bytes
+ *
+ * ty: u1 where:
+ * JVMPI_CLASS: object
+ * JVMPI_BOOLEAN: boolean
+ * JVMPI_CHAR: char
+ * JVMPI_FLOAT: float
+ * JVMPI_DOUBLE: double
+ * JVMPI_BYTE: byte
+ * JVMPI_SHORT: short
+ * JVMPI_INT: int
+ * JVMPI_LONG: long
+ *
+ * vl: values, exact type depends on the type of the value:
+ * JVMPI_BOOLEAN & JVMPI_BYTE: u1
+ * JVMPI_SHORT & JVMPI_CHAR: u2
+ * JVMPI_INT & JVMPI_FLOAT: u4
+ * JVMPI_LONG & JVMPI_DOUBLE: u8
+ * JVMPI_CLASS: jobjectID
+ */
+
+/* Format of the monitor dump buffer:
+ *
+ * u1 monitor type
+ *
+ * JVMPI_MONITOR_JAVA Java monitor
+ *
+ * jobjectID object
+ * JNIEnv * owner thread
+ * u4 entry count
+ * u4 # of threads waiting to enter
+ * [JNIEnv *]* threads waiting to enter
+ * u4 # of threads waiting to be notified
+ * [JNIEnv *]* threads waiting to be notified
+ *
+ * JVMPI_MONITOR_RAW raw monitor
+ *
+ * char * name
+ * JVMPI_RawMonitor raw monitor
+ * JNIEnv * owner thread
+ * u4 entry count
+ * u4 # of threads waiting to enter
+ * [JNIEnv *]* threads waiting to enter
+ * u4 # of threads waiting to be notified
+ * [JNIEnv *]* threads waiting to be notified
+ */
+
+/* Format of the heap dump buffer depends on the dump level
+ * specified in the JVMPI_HeapDumpArg passed to RequestEvent as arg.
+ * The default is JVMPI_DUMP_LEVEL_2.
+ *
+ * JVMPI_DUMP_LEVEL_0:
+ *
+ * u1 object type (JVMPI_CLASS ...)
+ * jobjectID object
+ *
+ * JVMPI_DUMP_LEVEL_1 and JVMPI_DUMP_LEVEL_2 use the following format:
+ * In the case of JVMPI_DUMP_LEVEL_1 the values of primitive fields in object
+ * instance dumps , the values of primitive statics in class dumps and the
+ * values of primitive arrays are excluded. JVMPI_DUMP_LEVEL_2 includes the
+ * primitive values.
+ *
+ * u1 record type
+ *
+ * JVMPI_GC_ROOT_UNKNOWN unknown root
+ *
+ * jobjectID object
+ *
+ * JVMPI_GC_ROOT_JNI_GLOBAL JNI global ref root
+ *
+ * jobjectID object
+ * jobject JNI global reference
+ *
+ * JVMPI_GC_ROOT_JNI_LOCAL JNI local ref
+ *
+ * jobjectID object
+ * JNIEnv * thread
+ * u4 frame # in stack trace (-1 for empty)
+ *
+ * JVMPI_GC_ROOT_JAVA_FRAME Java stack frame
+ *
+ * jobjectID object
+ * JNIEnv * thread
+ * u4 frame # in stack trace (-1 for empty)
+ *
+ * JVMPI_GC_ROOT_NATIVE_STACK Native stack
+ *
+ * jobjectID object
+ * JNIEnv * thread
+ *
+ * JVMPI_GC_ROOT_STICKY_CLASS System class
+ *
+ * jobjectID class object
+ *
+ * JVMPI_GC_ROOT_THREAD_BLOCK Reference from thread block
+ *
+ * jobjectID thread object
+ * JNIEnv * thread
+ *
+ * JVMPI_GC_ROOT_MONITOR_USED Busy monitor
+ *
+ * jobjectID object
+ *
+ * JVMPI_GC_CLASS_DUMP dump of a class object
+ *
+ * jobjectID class
+ * jobjectID super
+ * jobjectID class loader
+ * jobjectID signers
+ * jobjectID protection domain
+ * jobjectID class name
+ * void * reserved
+ *
+ * u4 instance size (in bytes)
+ *
+ * [jobjectID]* interfaces
+ *
+ * u2 size of constant pool
+ * [u2, constant pool index,
+ * ty, type,
+ * vl]* value
+ *
+ * [vl]* static field values
+ *
+ * JVMPI_GC_INSTANCE_DUMP dump of a normal object
+ *
+ * jobjectID object
+ * jobjectID class
+ * u4 number of bytes that follow
+ * [vl]* instance field values (class, followed
+ * by super, super's super ...)
+ *
+ * JVMPI_GC_OBJ_ARRAY_DUMP dump of an object array
+ *
+ * jobjectID array object
+ * u4 number of elements
+ * jobjectID element class
+ * [jobjectID]* elements
+ *
+ * JVMPI_GC_PRIM_ARRAY_DUMP dump of a primitive array
+ *
+ * jobjectID array object
+ * u4 number of elements
+ * ty element type
+ * [vl]* elements
+ *
+ */
+
+/* Format of the dump received in JVMPI_EVENT_OBJECT_DUMP:
+ * All the records have JVMPI_DUMP_LEVEL_2 information.
+ *
+ * u1 record type
+ *
+ * followed by a:
+ *
+ * JVMPI_GC_CLASS_DUMP,
+ * JVMPI_GC_INSTANCE_DUMP,
+ * JVMPI_GC_OBJ_ARRAY_DUMP, or
+ * JVMPI_GC_PRIM_ARRAY_DUMP record.
+ */
+
+#endif /* !_JAVASOFT_JVMPI_H_ */
--
cgit v1.2.3