diff options
Diffstat (limited to 'make/stub_includes/jni/macosx')
| -rw-r--r-- | make/stub_includes/jni/macosx/AWTCocoaComponent.h | 15 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/JDWP.h | 53 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/JDWPCommands.h | 238 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/jawt_md.h | 27 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/jni_md.h | 23 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/jvmdi.h | 1012 | ||||
| -rw-r--r-- | make/stub_includes/jni/macosx/jvmpi.h | 642 |
7 files changed, 2010 insertions, 0 deletions
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_ */ |