You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by lv...@apache.org on 2008/03/06 10:53:07 UTC
svn commit: r634205 - in
/harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native:
include/ include/jvmti.h include/jvmti_types.h jdwp/unix/agent/makefile
jdwp/windows/agent/makefile
Author: lvjing
Date: Thu Mar 6 01:52:51 2008
New Revision: 634205
URL: http://svn.apache.org/viewvc?rev=634205&view=rev
Log:
Add testcase of HARMONY-5579 [jdktools][jdwp6] Include updated jvmti.h of Java 6 in jdktools to build jdwp 6
Added:
harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/
harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h (with props)
harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h (with props)
Modified:
harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/unix/agent/makefile
harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/windows/agent/makefile
Added: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h?rev=634205&view=auto
==============================================================================
--- harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h (added)
+++ harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h Thu Mar 6 01:52:51 2008
@@ -0,0 +1,1451 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Gregory Shimansky
+ * @version $Revision: 1.1.2.1.4.4 $
+ */
+#ifndef _JVMTI_H_
+#define _JVMTI_H_
+
+#include <stdlib.h>
+
+#include "jni.h"
+#include "jvmti_types.h"
+
+/*
+ * Supported JVMTI versions
+ */
+#define JVMTI_VERSION_INTERFACE_JNI 0x00000000
+#define JVMTI_VERSION_INTERFACE_JVMTI 0x30000000
+#define JVMTI_VERSION_MASK_INTERFACE_TYPE 0x70000000
+#define JVMTI_VERSION_MASK_MAJOR 0x0FFF0000
+#define JVMTI_VERSION_MASK_MINOR 0x0000FF00
+#define JVMTI_VERSION_MASK_MICRO 0x000000FF
+#define JVMTI_VERSION_SHIFT_MAJOR 16
+#define JVMTI_VERSION_SHIFT_MINOR 8
+#define JVMTI_VERSION_SHIFT_MICRO 0
+
+#define JVMTI_VERSION_MAJOR 1
+#define JVMTI_VERSION_MINOR 0
+#define JVMTI_VERSION_MICRO 36
+
+#define JVMTI_VERSION_1_0 \
+ (JVMTI_VERSION_INTERFACE_JVMTI | \
+ (JVMTI_VERSION_MAJOR << JVMTI_VERSION_SHIFT_MAJOR) | \
+ (JVMTI_VERSION_MINOR << JVMTI_VERSION_SHIFT_MINOR) | \
+ (JVMTI_VERSION_MICRO << JVMTI_VERSION_SHIFT_MICRO))
+
+#define JVMTI_VERSION \
+ (JVMTI_VERSION_INTERFACE_JVMTI | \
+ (JVMTI_VERSION_MAJOR << JVMTI_VERSION_SHIFT_MAJOR) | \
+ (JVMTI_VERSION_MINOR << JVMTI_VERSION_SHIFT_MINOR) | \
+ (JVMTI_VERSION_MICRO << JVMTI_VERSION_SHIFT_MICRO))
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /**
+ * Agent Start-Up
+ * The library must export a start-up function with the following
+ * prototype:
+ */
+ JNIEXPORT jint JNICALL
+ Agent_OnLoad(JavaVM * vm, char *options, void *reserved);
+
+ /**
+ * Agent Shutdown
+ * The library may optionally export a shutdown function with the
+ * following prototype:
+ */
+ JNIEXPORT void JNICALL Agent_OnUnload(JavaVM * vm);
+
+#ifdef __cplusplus
+} /* extern "C" { */
+#endif
+
+
+struct ti_interface
+{
+ void *reserved1;
+
+ jvmtiError (JNICALL * SetEventNotificationMode) (jvmtiEnv * env,
+ jvmtiEventMode mode,
+ jvmtiEvent event_type,
+ jthread event_thread,
+ ...);
+
+ void *reserved3;
+
+ jvmtiError (JNICALL * GetAllThreads) (jvmtiEnv * env,
+ jint * threads_count_ptr,
+ jthread ** threads_ptr);
+
+ jvmtiError (JNICALL * SuspendThread) (jvmtiEnv * env, jthread thread);
+
+ jvmtiError (JNICALL * ResumeThread) (jvmtiEnv * env, jthread thread);
+
+ jvmtiError (JNICALL * StopThread) (jvmtiEnv * env,
+ jthread thread, jobject exception);
+
+ jvmtiError (JNICALL * InterruptThread) (jvmtiEnv * env, jthread thread);
+
+ jvmtiError (JNICALL * GetThreadInfo) (jvmtiEnv * env,
+ jthread thread,
+ jvmtiThreadInfo * info_ptr);
+
+ jvmtiError (JNICALL * GetOwnedMonitorInfo) (jvmtiEnv * env,
+ jthread thread,
+ jint *
+ owned_monitor_count_ptr,
+ jobject **
+ owned_monitors_ptr);
+
+ jvmtiError (JNICALL * GetCurrentContendedMonitor) (jvmtiEnv * env,
+ jthread thread,
+ jobject * monitor_ptr);
+
+ jvmtiError (JNICALL * RunAgentThread) (jvmtiEnv * env,
+ jthread thread,
+ jvmtiStartFunction proc,
+ const void *arg, jint priority);
+
+ jvmtiError (JNICALL * GetTopThreadGroups) (jvmtiEnv * env,
+ jint * group_count_ptr,
+ jthreadGroup ** groups_ptr);
+
+ jvmtiError (JNICALL * GetThreadGroupInfo) (jvmtiEnv * env,
+ jthreadGroup group,
+ jvmtiThreadGroupInfo *
+ info_ptr);
+
+ jvmtiError (JNICALL * GetThreadGroupChildren) (jvmtiEnv * env,
+ jthreadGroup group,
+ jint * thread_count_ptr,
+ jthread ** threads_ptr,
+ jint * group_count_ptr,
+ jthreadGroup **
+ groups_ptr);
+
+ jvmtiError (JNICALL * GetFrameCount) (jvmtiEnv * env,
+ jthread thread, jint * count_ptr);
+
+ jvmtiError (JNICALL * GetThreadState) (jvmtiEnv * env,
+ jthread thread,
+ jint * thread_state_ptr);
+
+ void *reserved18;
+
+ jvmtiError (JNICALL * GetFrameLocation) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jmethodID * method_ptr,
+ jlocation * location_ptr);
+
+ jvmtiError (JNICALL * NotifyFramePop) (jvmtiEnv * env,
+ jthread thread, jint depth);
+
+ jvmtiError (JNICALL * GetLocalObject) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jobject * value_ptr);
+
+ jvmtiError (JNICALL * GetLocalInt) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jint * value_ptr);
+
+ jvmtiError (JNICALL * GetLocalLong) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jlong * value_ptr);
+
+ jvmtiError (JNICALL * GetLocalFloat) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jfloat * value_ptr);
+
+ jvmtiError (JNICALL * GetLocalDouble) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jdouble * value_ptr);
+
+ jvmtiError (JNICALL * SetLocalObject) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jobject value);
+
+ jvmtiError (JNICALL * SetLocalInt) (jvmtiEnv * env,
+ jthread thread,
+ jint depth, jint slot, jint value);
+
+ jvmtiError (JNICALL * SetLocalLong) (jvmtiEnv * env,
+ jthread thread,
+ jint depth, jint slot, jlong value);
+
+ jvmtiError (JNICALL * SetLocalFloat) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jfloat value);
+
+ jvmtiError (JNICALL * SetLocalDouble) (jvmtiEnv * env,
+ jthread thread,
+ jint depth,
+ jint slot, jdouble value);
+
+ jvmtiError (JNICALL * CreateRawMonitor) (jvmtiEnv * env,
+ const char *name,
+ jrawMonitorID * monitor_ptr);
+
+ jvmtiError (JNICALL * DestroyRawMonitor) (jvmtiEnv * env,
+ jrawMonitorID monitor);
+
+ jvmtiError (JNICALL * RawMonitorEnter) (jvmtiEnv * env,
+ jrawMonitorID monitor);
+
+ jvmtiError (JNICALL * RawMonitorExit) (jvmtiEnv * env,
+ jrawMonitorID monitor);
+
+ jvmtiError (JNICALL * RawMonitorWait) (jvmtiEnv * env,
+ jrawMonitorID monitor,
+ jlong millis);
+
+ jvmtiError (JNICALL * RawMonitorNotify) (jvmtiEnv * env,
+ jrawMonitorID monitor);
+
+ jvmtiError (JNICALL * RawMonitorNotifyAll) (jvmtiEnv * env,
+ jrawMonitorID monitor);
+
+ jvmtiError (JNICALL * SetBreakpoint) (jvmtiEnv * env,
+ jmethodID method,
+ jlocation location);
+
+ jvmtiError (JNICALL * ClearBreakpoint) (jvmtiEnv * env,
+ jmethodID method,
+ jlocation location);
+
+ void *reserved40;
+
+ jvmtiError (JNICALL * SetFieldAccessWatch) (jvmtiEnv * env,
+ jclass clazz, jfieldID field);
+
+ jvmtiError (JNICALL * ClearFieldAccessWatch) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field);
+
+ jvmtiError (JNICALL * SetFieldModificationWatch) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field);
+
+ jvmtiError (JNICALL * ClearFieldModificationWatch) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field);
+
+ void *reserved45;
+
+ jvmtiError (JNICALL * Allocate) (jvmtiEnv * env,
+ jlong size, unsigned char **mem_ptr);
+
+ jvmtiError (JNICALL * Deallocate) (jvmtiEnv * env, unsigned char *mem);
+
+ jvmtiError (JNICALL * GetClassSignature) (jvmtiEnv * env,
+ jclass clazz,
+ char **signature_ptr,
+ char **generic_ptr);
+
+ jvmtiError (JNICALL * GetClassStatus) (jvmtiEnv * env,
+ jclass clazz, jint * status_ptr);
+
+ jvmtiError (JNICALL * GetSourceFileName) (jvmtiEnv * env,
+ jclass clazz,
+ char **source_name_ptr);
+
+ jvmtiError (JNICALL * GetClassModifiers) (jvmtiEnv * env,
+ jclass clazz,
+ jint * modifiers_ptr);
+
+ jvmtiError (JNICALL * GetClassMethods) (jvmtiEnv * env,
+ jclass clazz,
+ jint * method_count_ptr,
+ jmethodID ** methods_ptr);
+
+ jvmtiError (JNICALL * GetClassFields) (jvmtiEnv * env,
+ jclass clazz,
+ jint * field_count_ptr,
+ jfieldID ** fields_ptr);
+
+ jvmtiError (JNICALL * GetImplementedInterfaces) (jvmtiEnv * env,
+ jclass clazz,
+ jint *
+ interface_count_ptr,
+ jclass **
+ interfaces_ptr);
+
+ jvmtiError (JNICALL * IsInterface) (jvmtiEnv * env,
+ jclass clazz,
+ jboolean * is_interface_ptr);
+
+ jvmtiError (JNICALL * IsArrayClass) (jvmtiEnv * env,
+ jclass clazz,
+ jboolean * is_array_class_ptr);
+
+ jvmtiError (JNICALL * GetClassLoader) (jvmtiEnv * env,
+ jclass clazz,
+ jobject * classloader_ptr);
+
+ jvmtiError (JNICALL * GetObjectHashCode) (jvmtiEnv * env,
+ jobject object,
+ jint * hash_code_ptr);
+
+ jvmtiError (JNICALL * GetObjectMonitorUsage) (jvmtiEnv * env,
+ jobject object,
+ jvmtiMonitorUsage *
+ info_ptr);
+
+ jvmtiError (JNICALL * GetFieldName) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field,
+ char **name_ptr,
+ char **signature_ptr,
+ char **generic_ptr);
+
+ jvmtiError (JNICALL * GetFieldDeclaringClass) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field,
+ jclass *
+ declaring_class_ptr);
+
+ jvmtiError (JNICALL * GetFieldModifiers) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field,
+ jint * modifiers_ptr);
+
+ jvmtiError (JNICALL * IsFieldSynthetic) (jvmtiEnv * env,
+ jclass clazz,
+ jfieldID field,
+ jboolean * is_synthetic_ptr);
+
+ jvmtiError (JNICALL * GetMethodName) (jvmtiEnv * env,
+ jmethodID method,
+ char **name_ptr,
+ char **signature_ptr,
+ char **generic_ptr);
+
+ jvmtiError (JNICALL * GetMethodDeclaringClass) (jvmtiEnv * env,
+ jmethodID method,
+ jclass *
+ declaring_class_ptr);
+
+ jvmtiError (JNICALL * GetMethodModifiers) (jvmtiEnv * env,
+ jmethodID method,
+ jint * modifiers_ptr);
+
+ void *reserved67;
+
+ jvmtiError (JNICALL * GetMaxLocals) (jvmtiEnv * env,
+ jmethodID method, jint * max_ptr);
+
+ jvmtiError (JNICALL * GetArgumentsSize) (jvmtiEnv * env,
+ jmethodID method,
+ jint * size_ptr);
+
+ jvmtiError (JNICALL * GetLineNumberTable) (jvmtiEnv * env,
+ jmethodID method,
+ jint * entry_count_ptr,
+ jvmtiLineNumberEntry **
+ table_ptr);
+
+ jvmtiError (JNICALL * GetMethodLocation) (jvmtiEnv * env,
+ jmethodID method,
+ jlocation * start_location_ptr,
+ jlocation * end_location_ptr);
+
+ jvmtiError (JNICALL * GetLocalVariableTable) (jvmtiEnv * env,
+ jmethodID method,
+ jint * entry_count_ptr,
+ jvmtiLocalVariableEntry **
+ table_ptr);
+
+ void *reserved73;
+
+ void *reserved74;
+
+ jvmtiError (JNICALL * GetBytecodes) (jvmtiEnv * env,
+ jmethodID method,
+ jint * bytecode_count_ptr,
+ unsigned char **bytecodes_ptr);
+
+ jvmtiError (JNICALL * IsMethodNative) (jvmtiEnv * env,
+ jmethodID method,
+ jboolean * is_native_ptr);
+
+ jvmtiError (JNICALL * IsMethodSynthetic) (jvmtiEnv * env,
+ jmethodID method,
+ jboolean * is_synthetic_ptr);
+
+ jvmtiError (JNICALL * GetLoadedClasses) (jvmtiEnv * env,
+ jint * class_count_ptr,
+ jclass ** classes_ptr);
+
+ jvmtiError (JNICALL * GetClassLoaderClasses) (jvmtiEnv * env,
+ jobject initiating_loader,
+ jint * class_count_ptr,
+ jclass ** classes_ptr);
+
+ jvmtiError (JNICALL * PopFrame) (jvmtiEnv * env, jthread thread);
+
+ void *reserved81;
+
+ void *reserved82;
+
+ void *reserved83;
+
+ void *reserved84;
+
+ void *reserved85;
+
+ void *reserved86;
+
+ jvmtiError (JNICALL * RedefineClasses) (jvmtiEnv * env,
+ jint class_count,
+ const jvmtiClassDefinition *
+ class_definitions);
+
+ jvmtiError (JNICALL * GetVersionNumber) (jvmtiEnv * env,
+ jint * version_ptr);
+
+ jvmtiError (JNICALL * GetCapabilities) (jvmtiEnv * env,
+ jvmtiCapabilities *
+ capabilities_ptr);
+
+ jvmtiError (JNICALL * GetSourceDebugExtension) (jvmtiEnv * env,
+ jclass clazz,
+ char
+ **source_debug_extension_ptr);
+
+ jvmtiError (JNICALL * IsMethodObsolete) (jvmtiEnv * env,
+ jmethodID method,
+ jboolean * is_obsolete_ptr);
+
+ jvmtiError (JNICALL * SuspendThreadList) (jvmtiEnv * env,
+ jint request_count,
+ const jthread * request_list,
+ jvmtiError * results);
+
+ jvmtiError (JNICALL * ResumeThreadList) (jvmtiEnv * env,
+ jint request_count,
+ const jthread * request_list,
+ jvmtiError * results);
+
+ void *reserved94;
+
+ void *reserved95;
+
+ void *reserved96;
+
+ void *reserved97;
+
+ void *reserved98;
+
+ void *reserved99;
+
+ jvmtiError (JNICALL * GetAllStackTraces) (jvmtiEnv * env,
+ jint max_frame_count,
+ jvmtiStackInfo **
+ stack_info_ptr,
+ jint * thread_count_ptr);
+
+ jvmtiError (JNICALL * GetThreadListStackTraces) (jvmtiEnv * env,
+ jint thread_count,
+ const jthread *
+ thread_list,
+ jint max_frame_count,
+ jvmtiStackInfo **
+ stack_info_ptr);
+
+ jvmtiError (JNICALL * GetThreadLocalStorage) (jvmtiEnv * env,
+ jthread thread,
+ void **data_ptr);
+
+ jvmtiError (JNICALL * SetThreadLocalStorage) (jvmtiEnv * env,
+ jthread thread,
+ const void *data);
+
+ jvmtiError (JNICALL * GetStackTrace) (jvmtiEnv * env,
+ jthread thread,
+ jint start_depth,
+ jint max_frame_count,
+ jvmtiFrameInfo * frame_buffer,
+ jint * count_ptr);
+
+ void *reserved105;
+
+ jvmtiError (JNICALL * GetTag) (jvmtiEnv * env,
+ jobject object, jlong * tag_ptr);
+
+ jvmtiError (JNICALL * SetTag) (jvmtiEnv * env, jobject object, jlong tag);
+
+ jvmtiError (JNICALL * ForceGarbageCollection) (jvmtiEnv * env);
+
+ jvmtiError (JNICALL * IterateOverObjectsReachableFromObject) (jvmtiEnv *
+ env,
+ jobject
+ object,
+ jvmtiObjectReferenceCallback
+ object_reference_callback,
+ void
+ *user_data);
+
+ jvmtiError (JNICALL * IterateOverReachableObjects) (jvmtiEnv * env,
+ jvmtiHeapRootCallback
+ heap_root_callback,
+ jvmtiStackReferenceCallback
+ stack_ref_callback,
+ jvmtiObjectReferenceCallback
+ object_ref_callback,
+ void *user_data);
+
+ jvmtiError (JNICALL * IterateOverHeap) (jvmtiEnv * env,
+ jvmtiHeapObjectFilter
+ object_filter,
+ jvmtiHeapObjectCallback
+ heap_object_callback,
+ void *user_data);
+
+ jvmtiError (JNICALL * IterateOverInstancesOfClass) (jvmtiEnv * env,
+ jclass clazz,
+ jvmtiHeapObjectFilter
+ object_filter,
+ jvmtiHeapObjectCallback
+ heap_object_callback,
+ void *user_data);
+
+ void *reserved113;
+
+ jvmtiError (JNICALL * GetObjectsWithTags) (jvmtiEnv * env,
+ jint tag_count,
+ const jlong * tags,
+ jint * count_ptr,
+ jobject ** object_result_ptr,
+ jlong ** tag_result_ptr);
+
+ jvmtiError (JNICALL *FollowReferences) (jvmtiEnv* env,
+ jint heap_filter,
+ jclass klass,
+ jobject initial_object,
+ const jvmtiHeapCallbacks* callbacks,
+ const void* user_data);
+
+ void *reserved116;
+
+ void *reserved117;
+
+ void *reserved118;
+
+ void *reserved119;
+
+ jvmtiError (JNICALL * SetJNIFunctionTable) (jvmtiEnv * env,
+ const jniNativeInterface *
+ function_table);
+
+ jvmtiError (JNICALL * GetJNIFunctionTable) (jvmtiEnv * env,
+ jniNativeInterface **
+ function_table);
+
+ jvmtiError (JNICALL * SetEventCallbacks) (jvmtiEnv * env,
+ const jvmtiEventCallbacks *
+ callbacks,
+ jint size_of_callbacks);
+
+ jvmtiError (JNICALL * GenerateEvents) (jvmtiEnv * env,
+ jvmtiEvent event_type);
+
+ jvmtiError (JNICALL * GetExtensionFunctions) (jvmtiEnv * env,
+ jint * extension_count_ptr,
+ jvmtiExtensionFunctionInfo
+ ** extensions);
+
+ jvmtiError (JNICALL * GetExtensionEvents) (jvmtiEnv * env,
+ jint * extension_count_ptr,
+ jvmtiExtensionEventInfo **
+ extensions);
+
+ jvmtiError (JNICALL * SetExtensionEventCallback) (jvmtiEnv * env,
+ jint
+ extension_event_index,
+ jvmtiExtensionEvent
+ callback);
+
+ jvmtiError (JNICALL * DisposeEnvironment) (jvmtiEnv * env);
+
+ jvmtiError (JNICALL * GetErrorName) (jvmtiEnv * env,
+ jvmtiError error, char **name_ptr);
+
+ jvmtiError (JNICALL * GetJLocationFormat) (jvmtiEnv * env,
+ jvmtiJlocationFormat *
+ format_ptr);
+
+ jvmtiError (JNICALL * GetSystemProperties) (jvmtiEnv * env,
+ jint * count_ptr,
+ char ***property_ptr);
+
+ jvmtiError (JNICALL * GetSystemProperty) (jvmtiEnv * env,
+ const char *property,
+ char **value_ptr);
+
+ jvmtiError (JNICALL * SetSystemProperty) (jvmtiEnv * env,
+ const char *property,
+ const char *value);
+
+ jvmtiError (JNICALL * GetPhase) (jvmtiEnv * env, jvmtiPhase * phase_ptr);
+
+ jvmtiError (JNICALL * GetCurrentThreadCpuTimerInfo) (jvmtiEnv * env,
+ jvmtiTimerInfo *
+ info_ptr);
+
+ jvmtiError (JNICALL * GetCurrentThreadCpuTime) (jvmtiEnv * env,
+ jlong * nanos_ptr);
+
+ jvmtiError (JNICALL * GetThreadCpuTimerInfo) (jvmtiEnv * env,
+ jvmtiTimerInfo * info_ptr);
+
+ jvmtiError (JNICALL * GetThreadCpuTime) (jvmtiEnv * env,
+ jthread thread,
+ jlong * nanos_ptr);
+
+ jvmtiError (JNICALL * GetTimerInfo) (jvmtiEnv * env,
+ jvmtiTimerInfo * info_ptr);
+
+ jvmtiError (JNICALL * GetTime) (jvmtiEnv * env, jlong * nanos_ptr);
+
+
+ jvmtiError (JNICALL * GetPotentialCapabilities) (jvmtiEnv * env,
+ jvmtiCapabilities *
+ capabilities_ptr);
+
+ void *reserved141;
+
+ jvmtiError (JNICALL * AddCapabilities) (jvmtiEnv * env,
+ const jvmtiCapabilities *
+ capabilities_ptr);
+
+ jvmtiError (JNICALL * RelinquishCapabilities) (jvmtiEnv * env,
+ const jvmtiCapabilities *
+ capabilities_ptr);
+
+ jvmtiError (JNICALL * GetAvailableProcessors) (jvmtiEnv * env,
+ jint *
+ processor_count_ptr);
+
+ jvmtiError (JNICALL *GetClassVersionNumbers) (jvmtiEnv * env,
+ jclass klass,
+ jint* minor_version_ptr,
+ jint* major_version_ptr);
+
+ jvmtiError (JNICALL *GetConstantPool) (jvmtiEnv* env,
+ jclass klass,
+ jint* constant_pool_count_ptr,
+ jint* constant_pool_byte_count_ptr,
+ unsigned char** constant_pool_bytes_ptr);
+
+ jvmtiError (JNICALL * GetEnvironmentLocalStorage) (jvmtiEnv * env,
+ void **data_ptr);
+
+ jvmtiError (JNICALL * SetEnvironmentLocalStorage) (jvmtiEnv * env,
+ const void *data);
+
+ jvmtiError (JNICALL * AddToBootstrapClassLoaderSearch) (jvmtiEnv * env,
+ const char
+ *segment);
+
+ jvmtiError (JNICALL * SetVerboseFlag) (jvmtiEnv * env,
+ jvmtiVerboseFlag flag,
+ jboolean value);
+
+ void *reserved151;
+
+ void *reserved152;
+
+ void *reserved153;
+
+ jvmtiError (JNICALL * GetObjectSize) (jvmtiEnv * env,
+ jobject object, jlong * size_ptr);
+};
+
+
+struct jvmtiEnv_struct
+{
+ const struct ti_interface *funcs;
+
+#ifdef __cplusplus
+
+ jvmtiError Allocate (jlong size, unsigned char **mem_ptr)
+ {
+ return funcs->Allocate (this, size, mem_ptr);
+ }
+
+ jvmtiError Deallocate (unsigned char *mem)
+ {
+ return funcs->Deallocate (this, mem);
+ }
+
+ jvmtiError GetThreadState (jthread thread, jint * thread_state_ptr)
+ {
+ return funcs->GetThreadState (this, thread, thread_state_ptr);
+ }
+
+ jvmtiError GetAllThreads (jint * threads_count_ptr, jthread ** threads_ptr)
+ {
+ return funcs->GetAllThreads (this, threads_count_ptr, threads_ptr);
+ }
+
+ jvmtiError SuspendThread (jthread thread)
+ {
+ return funcs->SuspendThread (this, thread);
+ }
+
+ jvmtiError SuspendThreadList (jint request_count,
+ const jthread * request_list,
+ jvmtiError * results)
+ {
+ return funcs->SuspendThreadList (this, request_count, request_list,
+ results);
+ }
+
+ jvmtiError ResumeThread (jthread thread)
+ {
+ return funcs->ResumeThread (this, thread);
+ }
+
+ jvmtiError ResumeThreadList (jint request_count,
+ const jthread * request_list,
+ jvmtiError * results)
+ {
+ return funcs->ResumeThreadList (this, request_count, request_list,
+ results);
+ }
+
+ jvmtiError StopThread (jthread thread, jobject exception)
+ {
+ return funcs->StopThread (this, thread, exception);
+ }
+
+ jvmtiError InterruptThread (jthread thread)
+ {
+ return funcs->InterruptThread (this, thread);
+ }
+
+ jvmtiError GetThreadInfo (jthread thread, jvmtiThreadInfo * info_ptr)
+ {
+ return funcs->GetThreadInfo (this, thread, info_ptr);
+ }
+
+ jvmtiError GetOwnedMonitorInfo (jthread thread,
+ jint * owned_monitor_count_ptr,
+ jobject ** owned_monitors_ptr)
+ {
+ return funcs->GetOwnedMonitorInfo (this, thread,
+ owned_monitor_count_ptr,
+ owned_monitors_ptr);
+ }
+
+ jvmtiError GetCurrentContendedMonitor (jthread thread,
+ jobject * monitor_ptr)
+ {
+ return funcs->GetCurrentContendedMonitor (this, thread, monitor_ptr);
+ }
+
+ jvmtiError RunAgentThread (jthread thread,
+ jvmtiStartFunction proc,
+ const void *arg, jint priority)
+ {
+ return funcs->RunAgentThread (this, thread, proc, arg, priority);
+ }
+
+ jvmtiError SetThreadLocalStorage (jthread thread, const void *data)
+ {
+ return funcs->SetThreadLocalStorage (this, thread, data);
+ }
+
+ jvmtiError GetThreadLocalStorage (jthread thread, void **data_ptr)
+ {
+ return funcs->GetThreadLocalStorage (this, thread, data_ptr);
+ }
+
+ jvmtiError GetTopThreadGroups (jint * group_count_ptr,
+ jthreadGroup ** groups_ptr)
+ {
+ return funcs->GetTopThreadGroups (this, group_count_ptr, groups_ptr);
+ }
+
+ jvmtiError GetThreadGroupInfo (jthreadGroup group,
+ jvmtiThreadGroupInfo * info_ptr)
+ {
+ return funcs->GetThreadGroupInfo (this, group, info_ptr);
+ }
+
+ jvmtiError GetThreadGroupChildren (jthreadGroup group,
+ jint * thread_count_ptr,
+ jthread ** threads_ptr,
+ jint * group_count_ptr,
+ jthreadGroup ** groups_ptr)
+ {
+ return funcs->GetThreadGroupChildren (this, group, thread_count_ptr,
+ threads_ptr, group_count_ptr,
+ groups_ptr);
+ }
+
+ jvmtiError GetStackTrace (jthread thread,
+ jint start_depth,
+ jint max_frame_count,
+ jvmtiFrameInfo * frame_buffer, jint * count_ptr)
+ {
+ return funcs->GetStackTrace (this, thread, start_depth,
+ max_frame_count, frame_buffer, count_ptr);
+ }
+
+ jvmtiError GetAllStackTraces (jint max_frame_count,
+ jvmtiStackInfo ** stack_info_ptr,
+ jint * thread_count_ptr)
+ {
+ return funcs->GetAllStackTraces (this, max_frame_count,
+ stack_info_ptr, thread_count_ptr);
+ }
+
+ jvmtiError GetThreadListStackTraces (jint thread_count,
+ const jthread * thread_list,
+ jint max_frame_count,
+ jvmtiStackInfo ** stack_info_ptr)
+ {
+ return funcs->GetThreadListStackTraces (this, thread_count,
+ thread_list, max_frame_count,
+ stack_info_ptr);
+ }
+
+ jvmtiError GetFrameCount (jthread thread, jint * count_ptr)
+ {
+ return funcs->GetFrameCount (this, thread, count_ptr);
+ }
+
+ jvmtiError PopFrame (jthread thread)
+ {
+ return funcs->PopFrame (this, thread);
+ }
+
+ jvmtiError GetFrameLocation (jthread thread,
+ jint depth,
+ jmethodID * method_ptr,
+ jlocation * location_ptr)
+ {
+ return funcs->GetFrameLocation (this, thread, depth, method_ptr,
+ location_ptr);
+ }
+
+ jvmtiError NotifyFramePop (jthread thread, jint depth)
+ {
+ return funcs->NotifyFramePop (this, thread, depth);
+ }
+
+ jvmtiError GetTag (jobject object, jlong * tag_ptr)
+ {
+ return funcs->GetTag (this, object, tag_ptr);
+ }
+
+ jvmtiError SetTag (jobject object, jlong tag)
+ {
+ return funcs->SetTag (this, object, tag);
+ }
+
+ jvmtiError ForceGarbageCollection ()
+ {
+ return funcs->ForceGarbageCollection (this);
+ }
+
+ jvmtiError IterateOverObjectsReachableFromObject (jobject object,
+ jvmtiObjectReferenceCallback
+ object_reference_callback,
+ void *user_data)
+ {
+ return funcs->IterateOverObjectsReachableFromObject (this, object,
+ object_reference_callback,
+ user_data);
+ }
+
+ jvmtiError IterateOverReachableObjects (jvmtiHeapRootCallback
+ heap_root_callback,
+ jvmtiStackReferenceCallback
+ stack_ref_callback,
+ jvmtiObjectReferenceCallback
+ object_ref_callback,
+ void *user_data)
+ {
+ return funcs->IterateOverReachableObjects (this, heap_root_callback,
+ stack_ref_callback,
+ object_ref_callback,
+ user_data);
+ }
+
+ jvmtiError IterateOverHeap (jvmtiHeapObjectFilter object_filter,
+ jvmtiHeapObjectCallback heap_object_callback,
+ void *user_data)
+ {
+ return funcs->IterateOverHeap (this, object_filter,
+ heap_object_callback, user_data);
+ }
+
+ jvmtiError IterateOverInstancesOfClass (jclass clazz,
+ jvmtiHeapObjectFilter object_filter,
+ jvmtiHeapObjectCallback
+ heap_object_callback,
+ void *user_data)
+ {
+ return funcs->IterateOverInstancesOfClass (this, clazz, object_filter,
+ heap_object_callback,
+ user_data);
+ }
+
+ jvmtiError GetObjectsWithTags (jint tag_count,
+ const jlong * tags,
+ jint * count_ptr,
+ jobject ** object_result_ptr,
+ jlong ** tag_result_ptr)
+ {
+ return funcs->GetObjectsWithTags (this, tag_count, tags, count_ptr,
+ object_result_ptr, tag_result_ptr);
+ }
+
+ jvmtiError FollowReferences (jint heap_filter,
+ jclass klass,
+ jobject initial_object,
+ const jvmtiHeapCallbacks* callbacks,
+ const void* user_data)
+ {
+ return funcs->FollowReferences (this, heap_filter, klass, initial_object,
+ callbacks, user_data);
+ }
+
+ jvmtiError GetLocalObject (jthread thread,
+ jint depth, jint slot, jobject * value_ptr)
+ {
+ return funcs->GetLocalObject (this, thread, depth, slot, value_ptr);
+ }
+
+ jvmtiError GetLocalInt (jthread thread,
+ jint depth, jint slot, jint * value_ptr)
+ {
+ return funcs->GetLocalInt (this, thread, depth, slot, value_ptr);
+ }
+
+ jvmtiError GetLocalLong (jthread thread,
+ jint depth, jint slot, jlong * value_ptr)
+ {
+ return funcs->GetLocalLong (this, thread, depth, slot, value_ptr);
+ }
+
+ jvmtiError GetLocalFloat (jthread thread,
+ jint depth, jint slot, jfloat * value_ptr)
+ {
+ return funcs->GetLocalFloat (this, thread, depth, slot, value_ptr);
+ }
+
+ jvmtiError GetLocalDouble (jthread thread,
+ jint depth, jint slot, jdouble * value_ptr)
+ {
+ return funcs->GetLocalDouble (this, thread, depth, slot, value_ptr);
+ }
+
+ jvmtiError SetLocalObject (jthread thread,
+ jint depth, jint slot, jobject value)
+ {
+ return funcs->SetLocalObject (this, thread, depth, slot, value);
+ }
+
+ jvmtiError SetLocalInt (jthread thread, jint depth, jint slot, jint value)
+ {
+ return funcs->SetLocalInt (this, thread, depth, slot, value);
+ }
+
+ jvmtiError SetLocalLong (jthread thread, jint depth, jint slot, jlong value)
+ {
+ return funcs->SetLocalLong (this, thread, depth, slot, value);
+ }
+
+ jvmtiError SetLocalFloat (jthread thread,
+ jint depth, jint slot, jfloat value)
+ {
+ return funcs->SetLocalFloat (this, thread, depth, slot, value);
+ }
+
+ jvmtiError SetLocalDouble (jthread thread,
+ jint depth, jint slot, jdouble value)
+ {
+ return funcs->SetLocalDouble (this, thread, depth, slot, value);
+ }
+
+ jvmtiError SetBreakpoint (jmethodID method, jlocation location)
+ {
+ return funcs->SetBreakpoint (this, method, location);
+ }
+
+ jvmtiError ClearBreakpoint (jmethodID method, jlocation location)
+ {
+ return funcs->ClearBreakpoint (this, method, location);
+ }
+
+ jvmtiError SetFieldAccessWatch (jclass clazz, jfieldID field)
+ {
+ return funcs->SetFieldAccessWatch (this, clazz, field);
+ }
+
+ jvmtiError ClearFieldAccessWatch (jclass clazz, jfieldID field)
+ {
+ return funcs->ClearFieldAccessWatch (this, clazz, field);
+ }
+
+ jvmtiError SetFieldModificationWatch (jclass clazz, jfieldID field)
+ {
+ return funcs->SetFieldModificationWatch (this, clazz, field);
+ }
+
+ jvmtiError ClearFieldModificationWatch (jclass clazz, jfieldID field)
+ {
+ return funcs->ClearFieldModificationWatch (this, clazz, field);
+ }
+
+ jvmtiError GetLoadedClasses (jint * class_count_ptr, jclass ** classes_ptr)
+ {
+ return funcs->GetLoadedClasses (this, class_count_ptr, classes_ptr);
+ }
+
+ jvmtiError GetClassLoaderClasses (jobject initiating_loader,
+ jint * class_count_ptr,
+ jclass ** classes_ptr)
+ {
+ return funcs->GetClassLoaderClasses (this, initiating_loader,
+ class_count_ptr, classes_ptr);
+ }
+
+ jvmtiError GetClassSignature (jclass clazz,
+ char **signature_ptr, char **generic_ptr)
+ {
+ return funcs->GetClassSignature (this, clazz, signature_ptr, generic_ptr);
+ }
+
+ jvmtiError GetClassStatus (jclass clazz, jint * status_ptr)
+ {
+ return funcs->GetClassStatus (this, clazz, status_ptr);
+ }
+
+ jvmtiError GetSourceFileName (jclass clazz, char **source_name_ptr)
+ {
+ return funcs->GetSourceFileName (this, clazz, source_name_ptr);
+ }
+
+ jvmtiError GetClassModifiers (jclass clazz, jint * modifiers_ptr)
+ {
+ return funcs->GetClassModifiers (this, clazz, modifiers_ptr);
+ }
+
+ jvmtiError GetClassMethods (jclass clazz,
+ jint * method_count_ptr,
+ jmethodID ** methods_ptr)
+ {
+ return funcs->GetClassMethods (this, clazz, method_count_ptr,
+ methods_ptr);
+ }
+
+ jvmtiError GetClassFields (jclass clazz,
+ jint * field_count_ptr, jfieldID ** fields_ptr)
+ {
+ return funcs->GetClassFields (this, clazz, field_count_ptr, fields_ptr);
+ }
+
+ jvmtiError GetImplementedInterfaces (jclass clazz,
+ jint * interface_count_ptr,
+ jclass ** interfaces_ptr)
+ {
+ return funcs->GetImplementedInterfaces (this, clazz,
+ interface_count_ptr,
+ interfaces_ptr);
+ }
+
+ jvmtiError IsInterface (jclass clazz, jboolean * is_interface_ptr)
+ {
+ return funcs->IsInterface (this, clazz, is_interface_ptr);
+ }
+
+ jvmtiError IsArrayClass (jclass clazz, jboolean * is_array_class_ptr)
+ {
+ return funcs->IsArrayClass (this, clazz, is_array_class_ptr);
+ }
+
+ jvmtiError GetClassLoader (jclass clazz, jobject * classloader_ptr)
+ {
+ return funcs->GetClassLoader (this, clazz, classloader_ptr);
+ }
+
+ jvmtiError GetSourceDebugExtension (jclass clazz,
+ char **source_debug_extension_ptr)
+ {
+ return funcs->GetSourceDebugExtension (this, clazz,
+ source_debug_extension_ptr);
+ }
+
+ jvmtiError RedefineClasses (jint class_count,
+ const jvmtiClassDefinition * class_definitions)
+ {
+ return funcs->RedefineClasses (this, class_count, class_definitions);
+ }
+
+ jvmtiError GetObjectSize (jobject object, jlong * size_ptr)
+ {
+ return funcs->GetObjectSize (this, object, size_ptr);
+ }
+
+ jvmtiError GetObjectHashCode (jobject object, jint * hash_code_ptr)
+ {
+ return funcs->GetObjectHashCode (this, object, hash_code_ptr);
+ }
+
+ jvmtiError GetObjectMonitorUsage (jobject object,
+ jvmtiMonitorUsage * info_ptr)
+ {
+ return funcs->GetObjectMonitorUsage (this, object, info_ptr);
+ }
+
+ jvmtiError GetFieldName (jclass clazz,
+ jfieldID field,
+ char **name_ptr,
+ char **signature_ptr, char **generic_ptr)
+ {
+ return funcs->GetFieldName (this, clazz, field, name_ptr,
+ signature_ptr, generic_ptr);
+ }
+
+ jvmtiError GetFieldDeclaringClass (jclass clazz,
+ jfieldID field,
+ jclass * declaring_class_ptr)
+ {
+ return funcs->GetFieldDeclaringClass (this, clazz, field,
+ declaring_class_ptr);
+ }
+
+ jvmtiError GetFieldModifiers (jclass clazz,
+ jfieldID field, jint * modifiers_ptr)
+ {
+ return funcs->GetFieldModifiers (this, clazz, field, modifiers_ptr);
+ }
+
+ jvmtiError IsFieldSynthetic (jclass clazz,
+ jfieldID field, jboolean * is_synthetic_ptr)
+ {
+ return funcs->IsFieldSynthetic (this, clazz, field, is_synthetic_ptr);
+ }
+
+ jvmtiError GetMethodName (jmethodID method,
+ char **name_ptr,
+ char **signature_ptr, char **generic_ptr)
+ {
+ return funcs->GetMethodName (this, method, name_ptr, signature_ptr,
+ generic_ptr);
+ }
+
+ jvmtiError GetMethodDeclaringClass (jmethodID method,
+ jclass * declaring_class_ptr)
+ {
+ return funcs->GetMethodDeclaringClass (this, method, declaring_class_ptr);
+ }
+
+ jvmtiError GetMethodModifiers (jmethodID method, jint * modifiers_ptr)
+ {
+ return funcs->GetMethodModifiers (this, method, modifiers_ptr);
+ }
+
+ jvmtiError GetMaxLocals (jmethodID method, jint * max_ptr)
+ {
+ return funcs->GetMaxLocals (this, method, max_ptr);
+ }
+
+ jvmtiError GetArgumentsSize (jmethodID method, jint * size_ptr)
+ {
+ return funcs->GetArgumentsSize (this, method, size_ptr);
+ }
+
+ jvmtiError GetLineNumberTable (jmethodID method,
+ jint * entry_count_ptr,
+ jvmtiLineNumberEntry ** table_ptr)
+ {
+ return funcs->GetLineNumberTable (this, method, entry_count_ptr,
+ table_ptr);
+ }
+
+ jvmtiError GetMethodLocation (jmethodID method,
+ jlocation * start_location_ptr,
+ jlocation * end_location_ptr)
+ {
+ return funcs->GetMethodLocation (this, method, start_location_ptr,
+ end_location_ptr);
+ }
+
+ jvmtiError GetLocalVariableTable (jmethodID method,
+ jint * entry_count_ptr,
+ jvmtiLocalVariableEntry ** table_ptr)
+ {
+ return funcs->GetLocalVariableTable (this, method, entry_count_ptr,
+ table_ptr);
+ }
+
+ jvmtiError GetBytecodes (jmethodID method,
+ jint * bytecode_count_ptr,
+ unsigned char **bytecodes_ptr)
+ {
+ return funcs->GetBytecodes (this, method, bytecode_count_ptr,
+ bytecodes_ptr);
+ }
+
+ jvmtiError IsMethodNative (jmethodID method, jboolean * is_native_ptr)
+ {
+ return funcs->IsMethodNative (this, method, is_native_ptr);
+ }
+
+ jvmtiError IsMethodSynthetic (jmethodID method, jboolean * is_synthetic_ptr)
+ {
+ return funcs->IsMethodSynthetic (this, method, is_synthetic_ptr);
+ }
+
+ jvmtiError IsMethodObsolete (jmethodID method, jboolean * is_obsolete_ptr)
+ {
+ return funcs->IsMethodObsolete (this, method, is_obsolete_ptr);
+ }
+
+ jvmtiError CreateRawMonitor (const char *name, jrawMonitorID * monitor_ptr)
+ {
+ return funcs->CreateRawMonitor (this, name, monitor_ptr);
+ }
+
+ jvmtiError DestroyRawMonitor (jrawMonitorID monitor)
+ {
+ return funcs->DestroyRawMonitor (this, monitor);
+ }
+
+ jvmtiError RawMonitorEnter (jrawMonitorID monitor)
+ {
+ return funcs->RawMonitorEnter (this, monitor);
+ }
+
+ jvmtiError RawMonitorExit (jrawMonitorID monitor)
+ {
+ return funcs->RawMonitorExit (this, monitor);
+ }
+
+ jvmtiError RawMonitorWait (jrawMonitorID monitor, jlong millis)
+ {
+ return funcs->RawMonitorWait (this, monitor, millis);
+ }
+
+ jvmtiError RawMonitorNotify (jrawMonitorID monitor)
+ {
+ return funcs->RawMonitorNotify (this, monitor);
+ }
+
+ jvmtiError RawMonitorNotifyAll (jrawMonitorID monitor)
+ {
+ return funcs->RawMonitorNotifyAll (this, monitor);
+ }
+
+ jvmtiError SetJNIFunctionTable (const jniNativeInterface * function_table)
+ {
+ return funcs->SetJNIFunctionTable (this, function_table);
+ }
+
+ jvmtiError GetJNIFunctionTable (jniNativeInterface ** function_table)
+ {
+ return funcs->GetJNIFunctionTable (this, function_table);
+ }
+
+ jvmtiError SetEventCallbacks (const jvmtiEventCallbacks * callbacks,
+ jint size_of_callbacks)
+ {
+ return funcs->SetEventCallbacks (this, callbacks, size_of_callbacks);
+ }
+
+ jvmtiError SetEventNotificationMode (jvmtiEventMode mode,
+ jvmtiEvent event_type,
+ jthread event_thread, ...)
+ {
+ return funcs->SetEventNotificationMode (this, mode, event_type,
+ event_thread);
+ }
+
+ jvmtiError GenerateEvents (jvmtiEvent event_type)
+ {
+ return funcs->GenerateEvents (this, event_type);
+ }
+
+ jvmtiError GetExtensionFunctions (jint * extension_count_ptr,
+ jvmtiExtensionFunctionInfo ** extensions)
+ {
+ return funcs->GetExtensionFunctions (this, extension_count_ptr,
+ extensions);
+ }
+
+ jvmtiError GetExtensionEvents (jint * extension_count_ptr,
+ jvmtiExtensionEventInfo ** extensions)
+ {
+ return funcs->GetExtensionEvents (this, extension_count_ptr, extensions);
+ }
+
+ jvmtiError SetExtensionEventCallback (jint extension_event_index,
+ jvmtiExtensionEvent callback)
+ {
+ return funcs->SetExtensionEventCallback (this, extension_event_index,
+ callback);
+ }
+
+ jvmtiError GetPotentialCapabilities (jvmtiCapabilities * capabilities_ptr)
+ {
+ return funcs->GetPotentialCapabilities (this, capabilities_ptr);
+ }
+
+ jvmtiError AddCapabilities (const jvmtiCapabilities * capabilities_ptr)
+ {
+ return funcs->AddCapabilities (this, capabilities_ptr);
+ }
+
+ jvmtiError RelinquishCapabilities (const jvmtiCapabilities *
+ capabilities_ptr)
+ {
+ return funcs->RelinquishCapabilities (this, capabilities_ptr);
+ }
+
+ jvmtiError GetCapabilities (jvmtiCapabilities * capabilities_ptr)
+ {
+ return funcs->GetCapabilities (this, capabilities_ptr);
+ }
+
+ jvmtiError GetCurrentThreadCpuTimerInfo (jvmtiTimerInfo * info_ptr)
+ {
+ return funcs->GetCurrentThreadCpuTimerInfo (this, info_ptr);
+ }
+
+ jvmtiError GetCurrentThreadCpuTime (jlong * nanos_ptr)
+ {
+ return funcs->GetCurrentThreadCpuTime (this, nanos_ptr);
+ }
+
+ jvmtiError GetThreadCpuTimerInfo (jvmtiTimerInfo * info_ptr)
+ {
+ return funcs->GetThreadCpuTimerInfo (this, info_ptr);
+ }
+
+ jvmtiError GetThreadCpuTime (jthread thread, jlong * nanos_ptr)
+ {
+ return funcs->GetThreadCpuTime (this, thread, nanos_ptr);
+ }
+
+ jvmtiError GetTimerInfo (jvmtiTimerInfo * info_ptr)
+ {
+ return funcs->GetTimerInfo (this, info_ptr);
+ }
+
+ jvmtiError GetTime (jlong * nanos_ptr)
+ {
+ return funcs->GetTime (this, nanos_ptr);
+ }
+
+ jvmtiError GetAvailableProcessors (jint * processor_count_ptr)
+ {
+ return funcs->GetAvailableProcessors (this, processor_count_ptr);
+ }
+
+ jvmtiError GetClassVersionNumbers (jclass klass, jint* minor_version_ptr, jint* major_version_ptr)
+ {
+ return funcs->GetClassVersionNumbers (this, klass, minor_version_ptr, major_version_ptr);
+ }
+
+ jvmtiError GetConstantPool (jclass klass, jint* constant_pool_count_ptr,
+ jint* constant_pool_byte_count_ptr, unsigned char** constant_pool_bytes_ptr)
+ {
+ return funcs->GetConstantPool (this, klass, constant_pool_count_ptr, constant_pool_byte_count_ptr, constant_pool_bytes_ptr);
+ }
+
+ jvmtiError AddToBootstrapClassLoaderSearch (const char *segment)
+ {
+ return funcs->AddToBootstrapClassLoaderSearch (this, segment);
+ }
+
+ jvmtiError GetSystemProperties (jint * count_ptr, char ***property_ptr)
+ {
+ return funcs->GetSystemProperties (this, count_ptr, property_ptr);
+ }
+
+ jvmtiError GetSystemProperty (const char *property, char **value_ptr)
+ {
+ return funcs->GetSystemProperty (this, property, value_ptr);
+ }
+
+ jvmtiError SetSystemProperty (const char *property, const char *value)
+ {
+ return funcs->SetSystemProperty (this, property, value);
+ }
+
+ jvmtiError GetPhase (jvmtiPhase * phase_ptr)
+ {
+ return funcs->GetPhase (this, phase_ptr);
+ }
+
+ jvmtiError DisposeEnvironment ()
+ {
+ return funcs->DisposeEnvironment (this);
+ }
+
+ jvmtiError SetEnvironmentLocalStorage (const void *data)
+ {
+ return funcs->SetEnvironmentLocalStorage (this, data);
+ }
+
+ jvmtiError GetEnvironmentLocalStorage (void **data_ptr)
+ {
+ return funcs->GetEnvironmentLocalStorage (this, data_ptr);
+ }
+
+ jvmtiError GetVersionNumber (jint * version_ptr)
+ {
+ return funcs->GetVersionNumber (this, version_ptr);
+ }
+
+ jvmtiError GetErrorName (jvmtiError error, char **name_ptr)
+ {
+ return funcs->GetErrorName (this, error, name_ptr);
+ }
+
+ jvmtiError SetVerboseFlag (jvmtiVerboseFlag flag, jboolean value)
+ {
+ return funcs->SetVerboseFlag (this, flag, value);
+ }
+
+ jvmtiError GetJLocationFormat (jvmtiJlocationFormat * format_ptr)
+ {
+ return funcs->GetJLocationFormat (this, format_ptr);
+ }
+
+#endif
+
+};
+
+#endif /* _JVMTI_H_ */
Propchange: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti.h
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h?rev=634205&view=auto
==============================================================================
--- harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h (added)
+++ harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h Thu Mar 6 01:52:51 2008
@@ -0,0 +1,935 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+* @author Gregory Shimansky
+* @version $Revision: 1.1.2.1.4.4 $
+*/
+#ifndef _JVMTI_TYPES_H_
+#define _JVMTI_TYPES_H_
+
+#include "jni_types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /**
+ * Basic types
+ */
+ struct ti_interface;
+ struct jvmtiEnv_struct;
+
+#ifdef __cplusplus
+ typedef jvmtiEnv_struct jvmtiEnv;
+#else
+ typedef const struct ti_interface *jvmtiEnv;
+#endif
+
+ typedef jobject jthread;
+ typedef jlong jlocation;
+ typedef jobject jthreadGroup;
+ typedef int jrawMonitorID;
+ typedef struct JNINativeInterface_ jniNativeInterface;
+
+
+ /**
+ * Pointer to a function which could be launched
+ * as a separate system thread.
+ */
+ typedef void (JNICALL * jvmtiStartFunction)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg);
+
+ /**
+ * Heap visit control flags
+ */
+ enum {
+ JVMTI_VISIT_OBJECTS = 0x100,
+ JVMTI_VISIT_ABORT = 0x8000
+ };
+
+ /**
+ * Heap reference enumeration
+ */
+ typedef enum {
+ JVMTI_HEAP_REFERENCE_CLASS = 1,
+ JVMTI_HEAP_REFERENCE_FIELD = 2,
+ JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT = 3,
+ JVMTI_HEAP_REFERENCE_CLASS_LOADER = 4,
+ JVMTI_HEAP_REFERENCE_SIGNERS = 5,
+ JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN = 6,
+ JVMTI_HEAP_REFERENCE_INTERFACE = 7,
+ JVMTI_HEAP_REFERENCE_STATIC_FIELD = 8,
+ JVMTI_HEAP_REFERENCE_CONSTANT_POOL = 9,
+ JVMTI_HEAP_REFERENCE_SUPERCLASS = 10,
+ JVMTI_HEAP_REFERENCE_JNI_GLOBAL = 21,
+ JVMTI_HEAP_REFERENCE_SYSTEM_CLASS = 22,
+ JVMTI_HEAP_REFERENCE_MONITOR = 23,
+ JVMTI_HEAP_REFERENCE_STACK_LOCAL = 24,
+ JVMTI_HEAP_REFERENCE_JNI_LOCAL = 25,
+ JVMTI_HEAP_REFERENCE_THREAD = 26,
+ JVMTI_HEAP_REFERENCE_OTHER = 27
+ } jvmtiHeapReferenceKind;
+
+ /**
+ * Single character type descriptors of primitive types.
+ */
+ typedef enum {
+ JVMTI_PRIMITIVE_TYPE_BOOLEAN = 90,
+ JVMTI_PRIMITIVE_TYPE_BYTE = 66,
+ JVMTI_PRIMITIVE_TYPE_CHAR = 67,
+ JVMTI_PRIMITIVE_TYPE_SHORT = 83,
+ JVMTI_PRIMITIVE_TYPE_INT = 73,
+ JVMTI_PRIMITIVE_TYPE_LONG = 74,
+ JVMTI_PRIMITIVE_TYPE_FLOAT = 70,
+ JVMTI_PRIMITIVE_TYPE_DOUBLE = 68
+ } jvmtiPrimitiveType;
+
+ /**
+ * Reference information structure for Field references
+ */
+ typedef struct {
+ jint index;
+ } jvmtiHeapReferenceInfoField;
+
+ /**
+ * Reference information structure for Array references
+ */
+ typedef struct {
+ jint index;
+ } jvmtiHeapReferenceInfoArray;
+
+ /**
+ * Reference information structure for Constant Pool references
+ */
+ typedef struct {
+ jint index;
+ } jvmtiHeapReferenceInfoConstantPool;
+
+ /**
+ * Reference information structure for Local Variable references
+ */
+ typedef struct {
+ jlong thread_tag;
+ jlong thread_id;
+ jint depth;
+ jmethodID method;
+ jlocation location;
+ jint slot;
+ } jvmtiHeapReferenceInfoStackLocal;
+
+ /**
+ * Reference information structure for JNI local references
+ */
+ typedef struct {
+ jlong thread_tag;
+ jlong thread_id;
+ jint depth;
+ jmethodID method;
+ } jvmtiHeapReferenceInfoJniLocal;
+
+ /**
+ * Reference information structure for Other references
+ */
+ typedef struct {
+ jlong reserved1;
+ jlong reserved2;
+ jlong reserved3;
+ jlong reserved4;
+ jlong reserved5;
+ jlong reserved6;
+ jlong reserved7;
+ jlong reserved8;
+ } jvmtiHeapReferenceInfoReserved;
+
+ /**
+ * Represented as a union of the various kinds of reference information.
+ */
+ typedef union {
+ jvmtiHeapReferenceInfoField field;
+ jvmtiHeapReferenceInfoArray array;
+ jvmtiHeapReferenceInfoConstantPool constant_pool;
+ jvmtiHeapReferenceInfoStackLocal stack_local;
+ jvmtiHeapReferenceInfoJniLocal jni_local;
+ jvmtiHeapReferenceInfoReserved other;
+ } jvmtiHeapReferenceInfo;
+
+ /**
+ * Describes (but does not pass in) an object in the heap.
+ */
+ typedef jint (JNICALL *jvmtiHeapIterationCallback)
+ (jlong class_tag,
+ jlong size,
+ jlong* tag_ptr,
+ jint length,
+ void* user_data);
+
+ /**
+ * Describes a reference from an object or the VM (the referrer)
+ * to another object (the referree) or a heap root to a referree.
+ */
+ typedef jint (JNICALL *jvmtiHeapReferenceCallback)
+ (jvmtiHeapReferenceKind reference_kind,
+ const jvmtiHeapReferenceInfo* reference_info,
+ jlong class_tag,
+ jlong referrer_class_tag,
+ jlong size,
+ jlong* tag_ptr,
+ jlong* referrer_tag_ptr,
+ jint length,
+ void* user_data);
+
+ /**
+ * This callback will describe a static field if the object is a class,
+ * and otherwise will describe an instance field.
+ */
+ typedef jint (JNICALL *jvmtiPrimitiveFieldCallback)
+ (jvmtiHeapReferenceKind kind,
+ const jvmtiHeapReferenceInfo* info,
+ jlong object_class_tag,
+ jlong* object_tag_ptr,
+ jvalue value,
+ jvmtiPrimitiveType value_type,
+ void* user_data);
+
+ /**
+ * Describes the values in an array of a primitive type.
+ */
+ typedef jint (JNICALL *jvmtiArrayPrimitiveValueCallback)
+ (jlong class_tag,
+ jlong size,
+ jlong* tag_ptr,
+ jint element_count,
+ jvmtiPrimitiveType element_type,
+ const void* elements,
+ void* user_data);
+
+ /**
+ * Describes the value of a java.lang.String.
+ */
+ typedef jint (JNICALL *jvmtiStringPrimitiveValueCallback)
+ (jlong class_tag,
+ jlong size,
+ jlong* tag_ptr,
+ const jchar* value,
+ jint value_length,
+ void* user_data);
+
+ /**
+ * Reserved for future use.
+ */
+ typedef jint (JNICALL *jvmtiReservedCallback)
+ ();
+
+ /**
+ * Error codes.
+ */
+ typedef enum
+ {
+ JVMTI_ERROR_NONE = 0,
+ JVMTI_ERROR_NULL_POINTER = 100,
+ JVMTI_ERROR_OUT_OF_MEMORY = 110,
+ JVMTI_ERROR_ACCESS_DENIED = 111,
+ JVMTI_ERROR_UNATTACHED_THREAD = 115,
+ JVMTI_ERROR_INVALID_ENVIRONMENT = 116,
+ JVMTI_ERROR_WRONG_PHASE = 112,
+ JVMTI_ERROR_INTERNAL = 113,
+ JVMTI_ERROR_INVALID_PRIORITY = 12,
+ JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13,
+ JVMTI_ERROR_THREAD_SUSPENDED = 14,
+ JVMTI_ERROR_THREAD_NOT_ALIVE = 15,
+ JVMTI_ERROR_CLASS_NOT_PREPARED = 22,
+ JVMTI_ERROR_NO_MORE_FRAMES = 31,
+ JVMTI_ERROR_OPAQUE_FRAME = 32,
+ JVMTI_ERROR_DUPLICATE = 40,
+ JVMTI_ERROR_NOT_FOUND = 41,
+ JVMTI_ERROR_NOT_MONITOR_OWNER = 51,
+ JVMTI_ERROR_INTERRUPT = 52,
+ JVMTI_ERROR_UNMODIFIABLE_CLASS = 79,
+ JVMTI_ERROR_NOT_AVAILABLE = 98,
+ JVMTI_ERROR_ABSENT_INFORMATION = 101,
+ JVMTI_ERROR_INVALID_EVENT_TYPE = 102,
+ JVMTI_ERROR_NATIVE_METHOD = 104,
+ JVMTI_ERROR_INVALID_THREAD = 10,
+ JVMTI_ERROR_INVALID_FIELDID = 25,
+ JVMTI_ERROR_INVALID_METHODID = 23,
+ JVMTI_ERROR_INVALID_LOCATION = 24,
+ JVMTI_ERROR_INVALID_OBJECT = 20,
+ JVMTI_ERROR_INVALID_CLASS = 21,
+ JVMTI_ERROR_TYPE_MISMATCH = 34,
+ JVMTI_ERROR_INVALID_SLOT = 35,
+ JVMTI_ERROR_MUST_POSSESS_CAPABILITY = 99,
+ JVMTI_ERROR_INVALID_THREAD_GROUP = 11,
+ JVMTI_ERROR_INVALID_MONITOR = 50,
+ JVMTI_ERROR_ILLEGAL_ARGUMENT = 103,
+ JVMTI_ERROR_INVALID_TYPESTATE = 65,
+ JVMTI_ERROR_UNSUPPORTED_VERSION = 68,
+ JVMTI_ERROR_INVALID_CLASS_FORMAT = 60,
+ JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION = 61,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED = 63,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED = 64,
+ JVMTI_ERROR_FAILS_VERIFICATION = 62,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED = 66,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED = 67,
+ JVMTI_ERROR_NAMES_DONT_MATCH = 69,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED = 70,
+ JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED = 71,
+ JVMTI_NYI = 666
+ } jvmtiError;
+
+ /**
+ * Class status flags (from spec)
+ */
+ enum
+ {
+ /*
+ * Class bytecodes have been verified
+ */
+ JVMTI_CLASS_STATUS_VERIFIED = 1,
+ /*
+ * Class preparation is complete
+ */
+ JVMTI_CLASS_STATUS_PREPARED = 2,
+ /*
+ * Class initialization is complete. Static initializer has been run.
+ */
+ JVMTI_CLASS_STATUS_INITIALIZED = 4,
+ /*
+ * Error during initialization makes class unusable
+ */
+ JVMTI_CLASS_STATUS_ERROR = 8,
+ /*
+ * Class is an array. If set, all other bits are zero.
+ */
+ JVMTI_CLASS_STATUS_ARRAY = 16,
+ /*
+ * Class is a primitive class (for example, java.lang.Integer.TYPE).
+ * If set, all other bits are zero.
+ */
+ JVMTI_CLASS_STATUS_PRIMITIVE = 32
+ };
+
+ /**
+ * Thread states (from spec).
+ */
+ enum
+ {
+ JVMTI_THREAD_STATE_ALIVE = 0x0001,
+ JVMTI_THREAD_STATE_TERMINATED = 0x0002,
+ JVMTI_THREAD_STATE_RUNNABLE = 0x0004,
+ JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400,
+ JVMTI_THREAD_STATE_WAITING = 0x0080,
+ JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010,
+ JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020,
+ JVMTI_THREAD_STATE_SLEEPING = 0x0040,
+ JVMTI_THREAD_STATE_IN_OBJECT_WAIT = 0x0100,
+ JVMTI_THREAD_STATE_PARKED = 0x0200,
+ JVMTI_THREAD_STATE_SUSPENDED = 0x100000,
+ JVMTI_THREAD_STATE_INTERRUPTED = 0x200000,
+ JVMTI_THREAD_STATE_IN_NATIVE = 0x400000,
+ JVMTI_THREAD_STATE_VENDOR_1 = 0x10000000,
+ JVMTI_THREAD_STATE_VENDOR_2 = 0x20000000,
+ JVMTI_THREAD_STATE_VENDOR_3 = 0x40000000
+ };
+
+ enum
+ {
+ JVMTI_JAVA_LANG_THREAD_STATE_MASK =
+ JVMTI_THREAD_STATE_TERMINATED |
+ JVMTI_THREAD_STATE_ALIVE |
+ JVMTI_THREAD_STATE_RUNNABLE |
+ JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER |
+ JVMTI_THREAD_STATE_WAITING |
+ JVMTI_THREAD_STATE_WAITING_INDEFINITELY |
+ JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT,
+ JVMTI_JAVA_LANG_THREAD_STATE_NEW = 0,
+ JVMTI_JAVA_LANG_THREAD_STATE_TERMINATED = JVMTI_THREAD_STATE_TERMINATED,
+ JVMTI_JAVA_LANG_THREAD_STATE_RUNNABLE =
+ JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE,
+ JVMTI_JAVA_LANG_THREAD_STATE_BLOCKED =
+ JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
+ JVMTI_JAVA_LANG_THREAD_STATE_WAITING =
+ JVMTI_THREAD_STATE_ALIVE |
+ JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY,
+ JVMTI_JAVA_LANG_THREAD_STATE_TIMED_WAITING =
+ JVMTI_THREAD_STATE_ALIVE |
+ JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
+ };
+
+ /**
+ * Thread priorities (from spec).
+ */
+ enum
+ {
+ JVMTI_THREAD_MIN_PRIORITY = 1,
+ JVMTI_THREAD_NORM_PRIORITY = 5,
+ JVMTI_THREAD_MAX_PRIORITY = 10
+ };
+
+ /**
+ * Thread data (from spec).
+ */
+ typedef struct
+ {
+ char *name;
+ jint priority;
+ jboolean is_daemon;
+ jthreadGroup thread_group;
+ jobject context_class_loader;
+ } jvmtiThreadInfo;
+
+ /**
+ * Thread group data (from spec).
+ */
+ typedef struct
+ {
+ jthreadGroup parent;
+ char *name;
+ jint max_priority;
+ jboolean is_daemon;
+ } jvmtiThreadGroupInfo;
+
+ /**
+ * Stack frame data (from spec).
+ */
+ typedef struct
+ {
+ jmethodID method;
+ jlocation location;
+ } jvmtiFrameInfo;
+
+ /**
+ * Heap callback function structure
+ */
+ typedef struct {
+ jvmtiHeapIterationCallback heap_iteration_callback;
+ jvmtiHeapReferenceCallback heap_reference_callback;
+ jvmtiPrimitiveFieldCallback primitive_field_callback;
+ jvmtiArrayPrimitiveValueCallback array_primitive_value_callback;
+ jvmtiStringPrimitiveValueCallback string_primitive_value_callback;
+ jvmtiReservedCallback reserved5;
+ jvmtiReservedCallback reserved6;
+ jvmtiReservedCallback reserved7;
+ jvmtiReservedCallback reserved8;
+ jvmtiReservedCallback reserved9;
+ jvmtiReservedCallback reserved10;
+ jvmtiReservedCallback reserved11;
+ jvmtiReservedCallback reserved12;
+ jvmtiReservedCallback reserved13;
+ jvmtiReservedCallback reserved14;
+ jvmtiReservedCallback reserved15;
+ } jvmtiHeapCallbacks;
+
+ /**
+ * Thread stack data (from spec).
+ */
+ typedef struct
+ {
+ jthread thread;
+ jint state;
+ jvmtiFrameInfo *frame_buffer;
+ jint frame_count;
+ } jvmtiStackInfo;
+
+ /**
+ * Event numbers (from spec). Custom events could be added
+ * after JVMTI_MAX_EVENT_TYPE_VAL.
+ */
+ typedef enum
+ {
+ JVMTI_MIN_EVENT_TYPE_VAL = 50,
+ JVMTI_EVENT_VM_INIT = 50,
+ JVMTI_EVENT_VM_DEATH = 51,
+ JVMTI_EVENT_THREAD_START = 52,
+ JVMTI_EVENT_THREAD_END = 53,
+ JVMTI_EVENT_CLASS_FILE_LOAD_HOOK = 54,
+ JVMTI_EVENT_CLASS_LOAD = 55,
+ JVMTI_EVENT_CLASS_PREPARE = 56,
+ JVMTI_EVENT_VM_START = 57,
+ JVMTI_EVENT_EXCEPTION = 58,
+ JVMTI_EVENT_EXCEPTION_CATCH = 59,
+ JVMTI_EVENT_SINGLE_STEP = 60,
+ JVMTI_EVENT_FRAME_POP = 61,
+ JVMTI_EVENT_BREAKPOINT = 62,
+ JVMTI_EVENT_FIELD_ACCESS = 63,
+ JVMTI_EVENT_FIELD_MODIFICATION = 64,
+ JVMTI_EVENT_METHOD_ENTRY = 65,
+ JVMTI_EVENT_METHOD_EXIT = 66,
+ JVMTI_EVENT_NATIVE_METHOD_BIND = 67,
+ JVMTI_EVENT_COMPILED_METHOD_LOAD = 68,
+ JVMTI_EVENT_COMPILED_METHOD_UNLOAD = 69,
+ JVMTI_EVENT_DYNAMIC_CODE_GENERATED = 70,
+ JVMTI_EVENT_DATA_DUMP_REQUEST = 71,
+ JVMTI_EVENT_DATA_RESET_REQUEST = 72,
+ JVMTI_EVENT_MONITOR_WAIT = 73,
+ JVMTI_EVENT_MONITOR_WAITED = 74,
+ JVMTI_EVENT_MONITOR_CONTENDED_ENTER = 75,
+ JVMTI_EVENT_MONITOR_CONTENDED_ENTERED = 76,
+ JVMTI_EVENT_GARBAGE_COLLECTION_START = 81,
+ JVMTI_EVENT_GARBAGE_COLLECTION_FINISH = 82,
+ JVMTI_EVENT_OBJECT_FREE = 83,
+ JVMTI_EVENT_VM_OBJECT_ALLOC = 84,
+ JVMTI_MAX_EVENT_TYPE_VAL = 84
+ } jvmtiEvent;
+
+#define TOTAL_EVENT_TYPE_NUM (JVMTI_MAX_EVENT_TYPE_VAL - JVMTI_MIN_EVENT_TYPE_VAL + 1)
+
+ /**
+ * Root types.
+ */
+ typedef enum
+ {
+ JVMTI_HEAP_ROOT_JNI_GLOBAL = 1,
+ JVMTI_HEAP_ROOT_SYSTEM_CLASS = 2,
+ JVMTI_HEAP_ROOT_MONITOR = 3,
+ JVMTI_HEAP_ROOT_STACK_LOCAL = 4,
+ JVMTI_HEAP_ROOT_JNI_LOCAL = 5,
+ JVMTI_HEAP_ROOT_THREAD = 6,
+ JVMTI_HEAP_ROOT_OTHER = 7
+ } jvmtiHeapRootKind;
+
+ /**
+ * Generic iteration control.
+ */
+ typedef enum
+ {
+ JVMTI_ITERATION_CONTINUE = 1,
+ JVMTI_ITERATION_IGNORE = 2,
+ JVMTI_ITERATION_ABORT = 0
+ } jvmtiIterationControl;
+
+ /**
+ * Describes enumerated references.
+ */
+ typedef enum
+ {
+ JVMTI_REFERENCE_CLASS = 1,
+ JVMTI_REFERENCE_FIELD = 2,
+ JVMTI_REFERENCE_ARRAY_ELEMENT = 3,
+ JVMTI_REFERENCE_CLASS_LOADER = 4,
+ JVMTI_REFERENCE_SIGNERS = 5,
+ JVMTI_REFERENCE_PROTECTION_DOMAIN = 6,
+ JVMTI_REFERENCE_INTERFACE = 7,
+ JVMTI_REFERENCE_STATIC_FIELD = 8,
+ JVMTI_REFERENCE_CONSTANT_POOL = 9
+ } jvmtiObjectReferenceKind;
+
+ /**
+ * Mostly tag support resides on VM side, but GC
+ * should be aware of it.
+ */
+ typedef enum
+ {
+ JVMTI_HEAP_OBJECT_TAGGED = 1,
+ JVMTI_HEAP_OBJECT_UNTAGGED = 2,
+ JVMTI_HEAP_OBJECT_EITHER = 3
+ } jvmtiHeapObjectFilter;
+
+ typedef struct
+ {
+ jthread owner;
+ jint entry_count;
+ jint waiter_count;
+ jthread *waiters;
+ jint notify_waiter_count;
+ jthread *notify_waiters;
+ } jvmtiMonitorUsage;
+
+ typedef struct
+ {
+ jlocation start_location;
+ jint line_number;
+ } jvmtiLineNumberEntry;
+
+ typedef struct
+ {
+ jlocation start_location;
+ jint length;
+ char *name;
+ char *signature;
+ char *generic_signature;
+ jint slot;
+ } jvmtiLocalVariableEntry;
+
+ /* ******************************************************
+ * Event management is exposed to other OPEN components.
+ */
+
+ typedef void (JNICALL * jvmtiEventVMInit)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread);
+
+ typedef void (JNICALL * jvmtiEventSingleStep)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jlocation location);
+
+ typedef void (JNICALL * jvmtiEventBreakpoint)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jlocation location);
+
+ typedef void (JNICALL * jvmtiEventFieldAccess)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jlocation location, jclass field_clazz,
+ jobject object, jfieldID field);
+
+ typedef void (JNICALL * jvmtiEventFieldModification)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jlocation location, jclass field_clazz,
+ jobject object, jfieldID field, char signature_type, jvalue new_value);
+
+ typedef void (JNICALL * jvmtiEventFramePop)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jboolean was_popped_by_exception);
+
+ typedef void (JNICALL * jvmtiEventMethodEntry)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method);
+
+ typedef void (JNICALL * jvmtiEventMethodExit)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jboolean was_popped_by_exception, jvalue return_value);
+
+ typedef void (JNICALL * jvmtiEventNativeMethodBind)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, void *address, void **new_address_ptr);
+
+ typedef void (JNICALL * jvmtiEventException)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jmethodID method, jlocation location, jobject exception,
+ jmethodID catch_method, jlocation catch_location);
+
+ typedef void (JNICALL * jvmtiEventExceptionCatch)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env,
+ jthread thread, jmethodID method, jlocation location, jobject exception);
+
+ typedef void (JNICALL * jvmtiEventThreadStart)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread);
+
+ typedef void (JNICALL * jvmtiEventThreadEnd)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread);
+
+ typedef void (JNICALL * jvmtiEventClassLoad)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread, jclass clazz);
+
+ typedef void (JNICALL * jvmtiEventClassPrepare)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread, jclass clazz);
+
+ typedef void (JNICALL * jvmtiEventClassFileLoadHook)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env,
+ jclass class_being_redefined, jobject loader,
+ const char *name, jobject protection_domain,
+ jint class_data_len, const unsigned char *class_data,
+ jint * new_class_data_len, unsigned char **new_class_data);
+
+ typedef void (JNICALL * jvmtiEventVMStart)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env);
+
+ typedef void (JNICALL * jvmtiEventVMDeath)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env);
+
+ typedef struct
+ {
+ const void *start_address;
+ jlocation location;
+ } jvmtiAddrLocationMap;
+
+ typedef void (JNICALL * jvmtiEventCompiledMethodLoad)
+ (jvmtiEnv * jvmti_env, jmethodID method, jint code_size,
+ const void *code_addr, jint map_length,
+ const jvmtiAddrLocationMap * almap, const void *compile_info);
+
+ typedef void (JNICALL * jvmtiEventCompiledMethodUnload)
+ (jvmtiEnv * jvmti_env, jmethodID method, const void *code_addr);
+
+ typedef void (JNICALL * jvmtiEventDynamicCodeGenerated)
+ (jvmtiEnv * jvmti_env,
+ const char *name, const void *address, jint length);
+
+ typedef void (JNICALL * jvmtiEventDataDumpRequest) (jvmtiEnv * jvmti_env);
+
+ typedef void (JNICALL * jvmtiEventDataResetRequest) (jvmtiEnv * jvmti_env);
+
+ typedef void (JNICALL * jvmtiEventMonitorContendedEnter)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread, jobject object);
+
+ typedef void (JNICALL * jvmtiEventMonitorContendedEntered)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread, jobject object);
+
+ typedef void (JNICALL * jvmtiEventMonitorWait)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jobject object, jlong timeout);
+
+ typedef void (JNICALL * jvmtiEventMonitorWaited)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jobject object, jboolean timed_out);
+
+ typedef void (JNICALL * jvmtiEventVMObjectAlloc)
+ (jvmtiEnv * jvmti_env, JNIEnv * jni_env, jthread thread,
+ jobject object, jclass object_clazz, jlong size);
+
+ typedef void (JNICALL * jvmtiEventObjectFree)
+ (jvmtiEnv * jvmti_env, jlong tag);
+
+ typedef void (JNICALL * jvmtiEventGarbageCollectionStart)
+ (jvmtiEnv * jvmti_env);
+
+ typedef void (JNICALL * jvmtiEventGarbageCollectionFinish)
+ (jvmtiEnv * jvmti_env);
+
+ typedef void *jvmtiEventReserved;
+
+ typedef struct
+ {
+ jvmtiEventVMInit VMInit;
+ jvmtiEventVMDeath VMDeath;
+ jvmtiEventThreadStart ThreadStart;
+ jvmtiEventThreadEnd ThreadEnd;
+ jvmtiEventClassFileLoadHook ClassFileLoadHook;
+ jvmtiEventClassLoad ClassLoad;
+ jvmtiEventClassPrepare ClassPrepare;
+ jvmtiEventVMStart VMStart;
+ jvmtiEventException Exception;
+ jvmtiEventExceptionCatch ExceptionCatch;
+ jvmtiEventSingleStep SingleStep;
+ jvmtiEventFramePop FramePop;
+ jvmtiEventBreakpoint Breakpoint;
+ jvmtiEventFieldAccess FieldAccess;
+ jvmtiEventFieldModification FieldModification;
+ jvmtiEventMethodEntry MethodEntry;
+ jvmtiEventMethodExit MethodExit;
+ jvmtiEventNativeMethodBind NativeMethodBind;
+ jvmtiEventCompiledMethodLoad CompiledMethodLoad;
+ jvmtiEventCompiledMethodUnload CompiledMethodUnload;
+ jvmtiEventDynamicCodeGenerated DynamicCodeGenerated;
+ jvmtiEventDataDumpRequest DataDumpRequest;
+ jvmtiEventDataResetRequest DataResetRequest;
+ jvmtiEventMonitorWait MonitorWait;
+ jvmtiEventMonitorWaited MonitorWaited;
+ jvmtiEventMonitorContendedEnter MonitorContendedEnter;
+ jvmtiEventMonitorContendedEntered MonitorContendedEntered;
+ jvmtiEventReserved reserved77;
+ jvmtiEventReserved reserved78;
+ jvmtiEventReserved reserved79;
+ jvmtiEventReserved reserved80;
+ jvmtiEventGarbageCollectionStart GarbageCollectionStart;
+ jvmtiEventGarbageCollectionFinish GarbageCollectionFinish;
+ jvmtiEventObjectFree ObjectFree;
+ jvmtiEventVMObjectAlloc VMObjectAlloc;
+ } jvmtiEventCallbacks;
+
+
+ typedef enum
+ {
+ JVMTI_KIND_IN = 91,
+ JVMTI_KIND_IN_PTR = 92,
+ JVMTI_KIND_IN_BUF = 93,
+ JVMTI_KIND_ALLOC_BUF = 94,
+ JVMTI_KIND_ALLOC_ALLOC_BUF = 95,
+ JVMTI_KIND_OUT = 96,
+ JVMTI_KIND_OUT_BUF = 97
+ } jvmtiParamKind;
+
+ typedef enum
+ {
+ JVMTI_TYPE_JBYTE = 101,
+ JVMTI_TYPE_JCHAR = 102,
+ JVMTI_TYPE_JSHORT = 103,
+ JVMTI_TYPE_JINT = 104,
+ JVMTI_TYPE_JLONG = 105,
+ JVMTI_TYPE_JFLOAT = 106,
+ JVMTI_TYPE_JDOUBLE = 107,
+ JVMTI_TYPE_JBOOLEAN = 108,
+ JVMTI_TYPE_JOBJECT = 109,
+ JVMTI_TYPE_JTHREAD = 110,
+ JVMTI_TYPE_JCLASS = 111,
+ JVMTI_TYPE_JVALUE = 112,
+ JVMTI_TYPE_JFIELDID = 113,
+ JVMTI_TYPE_JMETHODID = 114,
+ JVMTI_TYPE_CCHAR = 115,
+ JVMTI_TYPE_CVOID = 116,
+ JVMTI_TYPE_JNIENV = 117
+ } jvmtiParamTypes;
+
+ typedef struct
+ {
+ char *name;
+ jvmtiParamKind kind;
+ jvmtiParamTypes base_type;
+ jboolean null_ok;
+ } jvmtiParamInfo;
+
+ typedef jvmtiError
+ (JNICALL * jvmtiExtensionFunction) (jvmtiEnv * jvmti_env, ...);
+
+ typedef enum
+ {
+ JVMTI_ENABLE = 1,
+ JVMTI_DISABLE = 0
+ } jvmtiEventMode;
+
+ typedef struct
+ {
+ jvmtiExtensionFunction func;
+ char *id;
+ char *short_description;
+ jint param_count;
+ jvmtiParamInfo *params;
+ jint error_count;
+ jvmtiError *errors;
+ } jvmtiExtensionFunctionInfo;
+
+ typedef struct
+ {
+ jint extension_event_index;
+ char *id;
+ char *short_description;
+ jint param_count;
+ jvmtiParamInfo *params;
+ } jvmtiExtensionEventInfo;
+
+ /**
+ * OPEN components should be aware of event management
+ * capabilities.
+ */
+ typedef struct
+ {
+ unsigned int can_tag_objects:1;
+ unsigned int can_generate_field_modification_events:1;
+ unsigned int can_generate_field_access_events:1;
+ unsigned int can_get_bytecodes:1;
+ unsigned int can_get_synthetic_attribute:1;
+ unsigned int can_get_owned_monitor_info:1;
+ unsigned int can_get_current_contended_monitor:1;
+ unsigned int can_get_monitor_info:1;
+ unsigned int can_pop_frame:1;
+ unsigned int can_redefine_classes:1;
+ unsigned int can_signal_thread:1;
+ unsigned int can_get_source_file_name:1;
+ unsigned int can_get_line_numbers:1;
+ unsigned int can_get_source_debug_extension:1;
+ unsigned int can_access_local_variables:1;
+ unsigned int can_maintain_original_method_order:1;
+ unsigned int can_generate_single_step_events:1;
+ unsigned int can_generate_exception_events:1;
+ unsigned int can_generate_frame_pop_events:1;
+ unsigned int can_generate_breakpoint_events:1;
+ unsigned int can_suspend:1;
+ unsigned int can_redefine_any_class:1;
+ unsigned int can_get_current_thread_cpu_time:1;
+ unsigned int can_get_thread_cpu_time:1;
+ unsigned int can_generate_method_entry_events:1;
+ unsigned int can_generate_method_exit_events:1;
+ unsigned int can_generate_all_class_hook_events:1;
+ unsigned int can_generate_compiled_method_load_events:1;
+ unsigned int can_generate_monitor_events:1;
+ unsigned int can_generate_vm_object_alloc_events:1;
+ unsigned int can_generate_native_method_bind_events:1;
+ unsigned int can_generate_garbage_collection_events:1;
+ unsigned int can_generate_object_free_events:1;
+ unsigned int can_force_early_return : 1;
+ unsigned int can_get_owned_monitor_stack_depth_info : 1;
+ unsigned int can_get_constant_pool : 1;
+ unsigned int can_set_native_method_prefix : 1;
+ unsigned int can_retransform_classes : 1;
+ unsigned int can_retransform_any_class : 1;
+ unsigned int can_generate_resource_exhaustion_heap_events : 1;
+ unsigned int can_generate_resource_exhaustion_threads_events : 1;
+
+ unsigned int:7;
+ unsigned int:16;
+ unsigned int:16;
+ unsigned int:16;
+ unsigned int:16;
+ unsigned int:16;
+ } jvmtiCapabilities;
+
+ typedef enum
+ {
+ JVMTI_TIMER_USER_CPU = 30,
+ JVMTI_TIMER_TOTAL_CPU = 31,
+ JVMTI_TIMER_ELAPSED = 32
+ } jvmtiTimerKind;
+
+ typedef struct
+ {
+ jlong max_value;
+ jboolean may_skip_forward;
+ jboolean may_skip_backward;
+ jvmtiTimerKind kind;
+ jlong reserved1;
+ jlong reserved2;
+ } jvmtiTimerInfo;
+
+ typedef enum
+ {
+ JVMTI_PHASE_ONLOAD = 1,
+ JVMTI_PHASE_PRIMORDIAL = 2,
+ JVMTI_PHASE_START = 6,
+ JVMTI_PHASE_LIVE = 4,
+ JVMTI_PHASE_DEAD = 8
+ } jvmtiPhase;
+
+ typedef enum
+ {
+ JVMTI_VERBOSE_OTHER = 0,
+ JVMTI_VERBOSE_GC = 1,
+ JVMTI_VERBOSE_CLASS = 2,
+ JVMTI_VERBOSE_JNI = 4
+ } jvmtiVerboseFlag;
+
+ typedef enum
+ {
+ JVMTI_JLOCATION_JVMBCI = 1,
+ JVMTI_JLOCATION_MACHINEPC = 2,
+ JVMTI_JLOCATION_OTHER = 0
+ } jvmtiJlocationFormat;
+
+ typedef jvmtiIterationControl
+ (JNICALL * jvmtiHeapObjectCallback)
+ (jlong class_tag, jlong size, jlong * tag_ptr, void *user_data);
+
+ typedef jvmtiIterationControl
+ (JNICALL * jvmtiHeapRootCallback)
+ (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
+ jlong * tag_ptr, void *user_data);
+
+ typedef jvmtiIterationControl
+ (JNICALL * jvmtiStackReferenceCallback)
+ (jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
+ jlong * tag_ptr, jlong thread_tag, jint depth, jmethodID method,
+ jint slot, void *user_data);
+
+ typedef jvmtiIterationControl
+ (JNICALL * jvmtiObjectReferenceCallback)
+ (jvmtiObjectReferenceKind reference_kind, jlong class_tag, jlong size,
+ jlong * tag_ptr, jlong referrer_tag, jint referrer_index,
+ void *user_data);
+
+ typedef struct
+ {
+ jclass klass;
+ jint class_byte_count;
+ const unsigned char *class_bytes;
+ } jvmtiClassDefinition;
+
+ typedef void (JNICALL * jvmtiExtensionEvent) (jvmtiEnv * jvmti_env, ...);
+
+#ifdef __cplusplus
+} /* extern "C" { */
+#endif
+
+
+#endif /* _JVMTI_TYPES_H_ */
Propchange: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/include/jvmti_types.h
------------------------------------------------------------------------------
svn:eol-style = native
Modified: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/unix/agent/makefile
URL: http://svn.apache.org/viewvc/harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/unix/agent/makefile?rev=634205&r1=634204&r2=634205&view=diff
==============================================================================
--- harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/unix/agent/makefile (original)
+++ harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/unix/agent/makefile Thu Mar 6 01:52:51 2008
@@ -28,6 +28,8 @@
INCLUDES += -I$(CMNAGENT)commands -I$(CMNAGENT)core \
-I$(COMMON)generic -Icore
+INCLUDES := -I../../../include $(INCLUDES)
+
LDFLAGS += -lstdc++
BUILDFILES = \
Modified: harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/windows/agent/makefile
URL: http://svn.apache.org/viewvc/harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/windows/agent/makefile?rev=634205&r1=634204&r2=634205&view=diff
==============================================================================
--- harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/windows/agent/makefile (original)
+++ harmony/enhanced/jdktools/branches/java6/modules/jpda/src/main/native/jdwp/windows/agent/makefile Thu Mar 6 01:52:51 2008
@@ -30,7 +30,7 @@
-I$(CMNAGENT)commands -I$(CMNAGENT)core \
-I$(COMMON)generic -Icore
-HYCFLAGS = $(HYCFLAGS) $(INCLUDES) -GX -wd4290
+HYCFLAGS = -I..\..\..\include $(HYCFLAGS) $(INCLUDES) -GX -wd4290
HYLDFLAGS = $(HYLDFLAGS) -def:$(LIBBASE).def