From ebf29cf63fabc0fa94e49f4c0107e7bc2619d0d2 Mon Sep 17 00:00:00 2001 From: Keith Seitz Date: Fri, 22 Sep 2006 02:12:12 +0000 Subject: jvmti.cc (_Jv_JVMTI_DisposeEnvironment): Check for enabled events. * jvmti.cc (_Jv_JVMTI_DisposeEnvironment): Check for enabled events. (check_enabled_event): New function. (check_enabled_events): New function. (post_event): New function. (_Jv_JVMTI_SetEventNotificationMode): New function. (_Jv_JVMTI_SetEventCallbacks): New function. (_Jv_JVMTI_Interface): Define SetEventNotificationMode and SetEventCallbacks members. * include/jvmti-int.h: New file. * include/jvmti_md.h (EVENT_SLOTS) [__GCJ_JNI_IMP__]: Define. (_CLASSPATH_JVMTIENV_CONTENTS) [__GCJ_JNI_IMPL__]: Define. * testsuite/libjava.jvmti/events.java: New file. * testsuite/libjava.jvmti/events.out: New file. * testsuite/libjava.jvmti/natevents.cc: New file. From-SVN: r117133 --- libjava/ChangeLog | 18 + libjava/include/jvmti-int.h | 85 ++++ libjava/include/jvmti_md.h | 28 +- libjava/jvmti.cc | 686 ++++++++++++++++++++++++++- libjava/testsuite/libjava.jvmti/events.java | 12 + libjava/testsuite/libjava.jvmti/events.out | 59 +++ libjava/testsuite/libjava.jvmti/natevents.cc | 544 +++++++++++++++++++++ 7 files changed, 1429 insertions(+), 3 deletions(-) create mode 100644 libjava/include/jvmti-int.h create mode 100644 libjava/testsuite/libjava.jvmti/events.java create mode 100644 libjava/testsuite/libjava.jvmti/events.out create mode 100644 libjava/testsuite/libjava.jvmti/natevents.cc (limited to 'libjava') diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 8b56d0d..a396f80 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,21 @@ +2006-09-21 Keith Seitz + + * jvmti.cc (_Jv_JVMTI_DisposeEnvironment): Check for enabled + events. + (check_enabled_event): New function. + (check_enabled_events): New function. + (post_event): New function. + (_Jv_JVMTI_SetEventNotificationMode): New function. + (_Jv_JVMTI_SetEventCallbacks): New function. + (_Jv_JVMTI_Interface): Define SetEventNotificationMode and + SetEventCallbacks members. + * include/jvmti-int.h: New file. + * include/jvmti_md.h (EVENT_SLOTS) [__GCJ_JNI_IMP__]: Define. + (_CLASSPATH_JVMTIENV_CONTENTS) [__GCJ_JNI_IMPL__]: Define. + * testsuite/libjava.jvmti/events.java: New file. + * testsuite/libjava.jvmti/events.out: New file. + * testsuite/libjava.jvmti/natevents.cc: New file. + 2006-09-21 Sandro Tolaini * configure.ac: Don't use darwin-signal.h as signal handler for diff --git a/libjava/include/jvmti-int.h b/libjava/include/jvmti-int.h new file mode 100644 index 0000000..36e0da8 --- /dev/null +++ b/libjava/include/jvmti-int.h @@ -0,0 +1,85 @@ +/* jvmti-int.h -- Internal JVMTI definitions + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +As a special exception, if you link this library with other files to +produce an executable, this library does not by itself cause the +resulting executable to be covered by the GNU General Public License. +This exception does not however invalidate any other reasons why the +executable file might be covered by the GNU General Public License. */ + +#ifndef __GCJ_JVTMI_INT_H__ +#define __GCJ_JVMTI_INT_H__ + +/* A macro to map jvmtiEvent to an index in thread[] and enabled[] + in the jvmtiEnv. This will only work if the order of events listed + in jvmtiEvent and jvmtiEventCallbacks is kept the same (which should + not be a problem). */ +#define EVENT_INDEX(jvmtievent) (int)(jvmtievent - JVMTI_EVENT_VM_INIT) + +/* A few globals to help limit the impact of JVMTI on normal operations. + False means no JVMTI environment requested that event type. */ +namespace JVMTI +{ + bool VMInit; + bool VMDeath; + bool ThreadStart; + bool ThreadEnd; + bool ClassFileLoadHook; + bool ClassLoad; + bool ClassPrepare; + bool VMStart; + bool Exception; + bool ExceptionCatch; + bool SingleStep; + bool FramePop; + bool Breakpoint; + bool FieldAccess; + bool FieldModification; + bool MethodEntry; + bool MethodExit; + bool NativeMethodBind; + bool CompiledMethodLoad; + bool CompiledMethodUnload; + bool DynamicCodeGenerated; + bool DataDumpRequest; + bool reserved72; + bool MonitorWait; + bool MonitorWaited; + bool MonitorContendedEnter; + bool MonitorContendedEntered; + bool reserved77; + bool reserved78; + bool reserved79; + bool reserved80; + bool GarbageCollectionStart; + bool GarbageCollectionFinish; + bool ObjectFree; + bool VMObjectAlloc; +}; + +/* A macro to test whether an event should be posted to JVMTI.*/ +#define JVMTI_REQUESTED_EVENT(Event) __builtin_expect (JVMTI::Event, false) + +/* Post the event to requesting JVMTI environments. + + For speed, this function should only be called after + JVMTI_REQUESTED_EVENT is checked. */ +extern void _Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...); +#endif /* __GCJ_JVMTI_INT_H__ */ diff --git a/libjava/include/jvmti_md.h b/libjava/include/jvmti_md.h index ab920b9..549d421 100644 --- a/libjava/include/jvmti_md.h +++ b/libjava/include/jvmti_md.h @@ -27,6 +27,32 @@ executable file might be covered by the GNU General Public License. */ #ifndef __GCJ_JVMTI_MD_H__ #define __GCJ_JVMTI_MD_H__ -// nothing +#ifdef __GCJ_JNI_IMPL__ + +/* If __GCJ_JNI_IMPL__ is defined, then we assume that we're building + libgcj itself, and we include functions which should not be exposed + to JVMTI users. */ + +/* The number of event slots needed to keep track of event reporting + constraints for an environment. This will only work if the order of + events listed in jvmtiEvent and jvmtiEventCallbacks is kept the same + (which should not be a problem). */ +#define EVENT_SLOTS \ + (int)(JVMTI_EVENT_VM_OBJECT_ALLOC - JVMTI_EVENT_VM_INIT + 1) + +/* Contents of the jvmtiEnv; but only inside the implementation. */ +#define _CLASSPATH_JVMTIENV_CONTENTS \ + /* Event handlers registered via SetEventCallbacks */ \ + jvmtiEventCallbacks callbacks; \ + \ + /* Array of event thread for which to report event. */ \ + /* NULL means all threads. One for each callback. */ \ + jthread thread[EVENT_SLOTS]; \ + \ + /* Array of notification modes for callbacks. */ \ + /* One for each callback. */ \ + bool enabled[EVENT_SLOTS]; + +#endif /* __GCJ_JNI_IMPL__ */ #endif /* __GCJ_JVMTI_MD_H__ */ diff --git a/libjava/jvmti.cc b/libjava/jvmti.cc index 22b76fb..5adc2cd 100644 --- a/libjava/jvmti.cc +++ b/libjava/jvmti.cc @@ -15,6 +15,7 @@ details. */ #include #include #include +#include "jvmti-int.h" #include @@ -32,6 +33,9 @@ details. */ #include #include +static void check_enabled_events (void); +static void check_enabled_event (jvmtiEvent); + extern struct JNINativeInterface _Jv_JNIFunctions; struct _Jv_rawMonitorID @@ -519,6 +523,9 @@ _Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env) } _Jv_Free (env); + + check_enabled_events (); + return JVMTI_ERROR_NONE; } @@ -665,6 +672,300 @@ _Jv_JVMTI_GetObjectSize (MAYBE_UNUSED jvmtiEnv *env, jobject object, return JVMTI_ERROR_NONE; } +/* An event is enabled only if it has both an event handler + and it is enabled in the environment. */ +static void +check_enabled_event (jvmtiEvent type) +{ + bool *enabled; + int offset; + +#define GET_OFFSET(Event) \ + do \ + { \ + enabled = &JVMTI::Event; \ + offset = offsetof (jvmtiEventCallbacks, Event); \ + } \ + while (0) + + switch (type) + { + case JVMTI_EVENT_VM_INIT: + GET_OFFSET (VMInit); + break; + + case JVMTI_EVENT_VM_DEATH: + GET_OFFSET (VMDeath); + break; + + case JVMTI_EVENT_THREAD_START: + GET_OFFSET (ThreadStart); + break; + + case JVMTI_EVENT_THREAD_END: + GET_OFFSET (ThreadEnd); + break; + + case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK: + GET_OFFSET (ClassFileLoadHook); + break; + + case JVMTI_EVENT_CLASS_LOAD: + GET_OFFSET (ClassLoad); + break; + + case JVMTI_EVENT_CLASS_PREPARE: + GET_OFFSET (ClassPrepare); + break; + + case JVMTI_EVENT_VM_START: + GET_OFFSET (VMStart); + break; + + case JVMTI_EVENT_EXCEPTION: + GET_OFFSET (Exception); + break; + + case JVMTI_EVENT_EXCEPTION_CATCH: + GET_OFFSET (ExceptionCatch); + break; + + case JVMTI_EVENT_SINGLE_STEP: + GET_OFFSET (SingleStep); + break; + + case JVMTI_EVENT_FRAME_POP: + GET_OFFSET (FramePop); + break; + + case JVMTI_EVENT_BREAKPOINT: + GET_OFFSET (Breakpoint); + break; + + case JVMTI_EVENT_FIELD_ACCESS: + GET_OFFSET (FieldAccess); + break; + + case JVMTI_EVENT_FIELD_MODIFICATION: + GET_OFFSET (FieldModification); + break; + + case JVMTI_EVENT_METHOD_ENTRY: + GET_OFFSET (MethodEntry); + break; + + case JVMTI_EVENT_METHOD_EXIT: + GET_OFFSET (MethodExit); + break; + + case JVMTI_EVENT_NATIVE_METHOD_BIND: + GET_OFFSET (NativeMethodBind); + break; + + case JVMTI_EVENT_COMPILED_METHOD_LOAD: + GET_OFFSET (CompiledMethodLoad); + break; + + case JVMTI_EVENT_COMPILED_METHOD_UNLOAD: + GET_OFFSET (CompiledMethodUnload); + break; + + case JVMTI_EVENT_DYNAMIC_CODE_GENERATED: + GET_OFFSET (DynamicCodeGenerated); + break; + + case JVMTI_EVENT_DATA_DUMP_REQUEST: + GET_OFFSET (DataDumpRequest); + break; + + case JVMTI_EVENT_MONITOR_WAIT: + GET_OFFSET (MonitorWait); + break; + + case JVMTI_EVENT_MONITOR_WAITED: + GET_OFFSET (MonitorWaited); + break; + + case JVMTI_EVENT_MONITOR_CONTENDED_ENTER: + GET_OFFSET (MonitorContendedEnter); + break; + + case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED: + GET_OFFSET (MonitorContendedEntered); + break; + + case JVMTI_EVENT_GARBAGE_COLLECTION_START: + GET_OFFSET (GarbageCollectionStart); + break; + + case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH: + GET_OFFSET (GarbageCollectionFinish); + break; + + case JVMTI_EVENT_OBJECT_FREE: + GET_OFFSET (ObjectFree); + break; + + case JVMTI_EVENT_VM_OBJECT_ALLOC: + GET_OFFSET (VMObjectAlloc); + break; + + default: + fprintf (stderr, + "libgcj: check_enabled_event for unknown JVMTI event (%d)\n", + (int) type); + return; + } +#undef GET_OFFSET + + int index = EVENT_INDEX (type); // safe since caller checks this + + JvSynchronize dummy (_envListLock); + struct jvmti_env_list *e; + FOREACH_ENVIRONMENT (e) + { + char *addr + = reinterpret_cast (&e->env->callbacks) + offset; + void **callback = reinterpret_cast (addr); + if (e->env->enabled[index] && *callback != NULL) + { + *enabled = true; + return; + } + } + + *enabled = false; +} + +static void +check_enabled_events () +{ + check_enabled_event (JVMTI_EVENT_VM_INIT); + check_enabled_event (JVMTI_EVENT_VM_DEATH); + check_enabled_event (JVMTI_EVENT_THREAD_START); + check_enabled_event (JVMTI_EVENT_THREAD_END); + check_enabled_event (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK); + check_enabled_event (JVMTI_EVENT_CLASS_LOAD); + check_enabled_event (JVMTI_EVENT_CLASS_PREPARE); + check_enabled_event (JVMTI_EVENT_VM_START); + check_enabled_event (JVMTI_EVENT_EXCEPTION); + check_enabled_event (JVMTI_EVENT_EXCEPTION_CATCH); + check_enabled_event (JVMTI_EVENT_SINGLE_STEP); + check_enabled_event (JVMTI_EVENT_FRAME_POP); + check_enabled_event (JVMTI_EVENT_BREAKPOINT); + check_enabled_event (JVMTI_EVENT_FIELD_ACCESS); + check_enabled_event (JVMTI_EVENT_FIELD_MODIFICATION); + check_enabled_event (JVMTI_EVENT_METHOD_ENTRY); + check_enabled_event (JVMTI_EVENT_METHOD_EXIT); + check_enabled_event (JVMTI_EVENT_NATIVE_METHOD_BIND); + check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_LOAD); + check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_UNLOAD); + check_enabled_event (JVMTI_EVENT_DYNAMIC_CODE_GENERATED); + check_enabled_event (JVMTI_EVENT_DATA_DUMP_REQUEST); + check_enabled_event (JVMTI_EVENT_MONITOR_WAIT); + check_enabled_event (JVMTI_EVENT_MONITOR_WAITED); + check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTER); + check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED); + check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_START); + check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH); + check_enabled_event (JVMTI_EVENT_OBJECT_FREE); + check_enabled_event (JVMTI_EVENT_VM_OBJECT_ALLOC); +} + +static jvmtiError JNICALL +_Jv_JVMTI_SetEventNotificationMode (jvmtiEnv *env, jvmtiEventMode mode, + jvmtiEvent type, jthread event_thread, ...) +{ + REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE); + + if (event_thread != NULL) + { + using namespace java::lang; + Thread *t = reinterpret_cast (event_thread); + THREAD_CHECK_VALID (t); + THREAD_CHECK_IS_ALIVE (t); + } + + bool enabled; + switch (mode) + { + case JVMTI_DISABLE: + enabled = false; + break; + case JVMTI_ENABLE: + enabled = true; + break; + + default: + return JVMTI_ERROR_ILLEGAL_ARGUMENT; + } + + switch (type) + { + case JVMTI_EVENT_VM_INIT: + case JVMTI_EVENT_VM_DEATH: + case JVMTI_EVENT_THREAD_START: + case JVMTI_EVENT_VM_START: + case JVMTI_EVENT_COMPILED_METHOD_LOAD: + case JVMTI_EVENT_COMPILED_METHOD_UNLOAD: + case JVMTI_EVENT_DYNAMIC_CODE_GENERATED: + case JVMTI_EVENT_DATA_DUMP_REQUEST: + ILLEGAL_ARGUMENT (event_thread != NULL); + break; + + case JVMTI_EVENT_THREAD_END: + case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK: + case JVMTI_EVENT_CLASS_LOAD: + case JVMTI_EVENT_CLASS_PREPARE: + case JVMTI_EVENT_EXCEPTION: + case JVMTI_EVENT_EXCEPTION_CATCH: + case JVMTI_EVENT_SINGLE_STEP: + case JVMTI_EVENT_FRAME_POP: + case JVMTI_EVENT_BREAKPOINT: + case JVMTI_EVENT_FIELD_ACCESS: + case JVMTI_EVENT_FIELD_MODIFICATION: + case JVMTI_EVENT_METHOD_ENTRY: + case JVMTI_EVENT_METHOD_EXIT: + case JVMTI_EVENT_NATIVE_METHOD_BIND: + case JVMTI_EVENT_MONITOR_WAIT: + case JVMTI_EVENT_MONITOR_WAITED: + case JVMTI_EVENT_MONITOR_CONTENDED_ENTER: + case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED: + case JVMTI_EVENT_GARBAGE_COLLECTION_START: + case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH: + case JVMTI_EVENT_OBJECT_FREE: + case JVMTI_EVENT_VM_OBJECT_ALLOC: + break; + + default: + return JVMTI_ERROR_INVALID_EVENT_TYPE; + } + + env->thread[EVENT_INDEX(type)] = event_thread; + env->enabled[EVENT_INDEX(type)] = enabled; + check_enabled_event (type); + return JVMTI_ERROR_NONE; +} + +static jvmtiError JNICALL +_Jv_JVMTI_SetEventCallbacks (jvmtiEnv *env, + const jvmtiEventCallbacks *callbacks, + jint size_of_callbacks) +{ + REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE); + ILLEGAL_ARGUMENT (size_of_callbacks < 0); + + // Copy the list of callbacks into the environment + memcpy (&env->callbacks, callbacks, sizeof (jvmtiEventCallbacks)); + + /* Check which events are now enabeld (JVMTI makes no requirements + about the order in which SetEventCallbacks and SetEventNotifications + are called. So we must check all events here. */ + check_enabled_events (); + + return JVMTI_ERROR_NONE; +} + jvmtiError _Jv_JVMTI_GetErrorName (MAYBE_UNUSED jvmtiEnv *env, jvmtiError error, char **name_ptr) @@ -884,7 +1185,7 @@ _Jv_JVMTI_GetErrorName (MAYBE_UNUSED jvmtiEnv *env, jvmtiError error, struct _Jv_jvmtiEnv _Jv_JVMTI_Interface = { RESERVED, // reserved1 - UNIMPLEMENTED, // SetEventNotification + _Jv_JVMTI_SetEventNotificationMode, // SetEventNotificationMode RESERVED, // reserved3 UNIMPLEMENTED, // GetAllThreads _Jv_JVMTI_SuspendThread, // SuspendThread @@ -1004,7 +1305,7 @@ struct _Jv_jvmtiEnv _Jv_JVMTI_Interface = RESERVED, // reserved119 _Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable _Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable - UNIMPLEMENTED, // SetEventCallbacks + _Jv_JVMTI_SetEventCallbacks, // SetEventCallbacks UNIMPLEMENTED, // GenerateEvents UNIMPLEMENTED, // GetExtensionFunctions UNIMPLEMENTED, // GetExtensionEvents @@ -1072,4 +1373,385 @@ _Jv_JVMTI_Init () { _jvmtiEnvironments = NULL; _envListLock = new java::lang::Object (); + + // No environments, so this should set all JVMTI:: members to false + check_enabled_events (); +} + +static void +post_event (jvmtiEnv *env, jvmtiEvent type, jthread event_thread, va_list args) +{ +#define ARG(Type,Name) Type Name = (Type) va_arg (args, Type) + +#define GET_BOOLEAN_ARG(Name) \ + ARG (int, b); \ + jboolean Name = (b == 0) ? false : true + +#define GET_CHAR_ARG(Name) \ + ARG (int, c); \ + char Name = static_cast (c) + + switch (type) + { + case JVMTI_EVENT_VM_INIT: + if (env->callbacks.VMInit != NULL) + { + ARG (JNIEnv *, jni_env); + env->callbacks.VMInit (env, jni_env, event_thread); + } + break; + + case JVMTI_EVENT_VM_DEATH: + if (env->callbacks.VMDeath != NULL) + { + ARG (JNIEnv *, jni_env); + env->callbacks.VMDeath (env, jni_env); + } + break; + + case JVMTI_EVENT_THREAD_START: + if (env->callbacks.ThreadStart != NULL) + { + ARG (JNIEnv *, jni_env); + env->callbacks.ThreadStart (env, jni_env, event_thread); + } + break; + + case JVMTI_EVENT_THREAD_END: + if (env->callbacks.ThreadEnd != NULL) + { + ARG (JNIEnv *, jni_env); + env->callbacks.ThreadEnd (env, jni_env, event_thread); + } + break; + + case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK: + if (env->callbacks.ClassFileLoadHook != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jclass, class_being_redefined); + ARG (jobject, loader); + ARG (const char *, name); + ARG (jobject, protection_domain); + ARG (jint, class_data_len); + ARG (const unsigned char *, class_data); + ARG (jint *, new_class_data_len); + ARG (unsigned char **, new_class_data); + env->callbacks.ClassFileLoadHook (env, jni_env, + class_being_redefined, loader, + name, protection_domain, + class_data_len, class_data, + new_class_data_len, + new_class_data); + } + break; + + case JVMTI_EVENT_CLASS_LOAD: + if (env->callbacks.ClassLoad != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jclass, klass); + env->callbacks.ClassLoad (env, jni_env, event_thread, klass); + } + break; + + case JVMTI_EVENT_CLASS_PREPARE: + if (env->callbacks.ClassPrepare != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jclass, klass); + env->callbacks.ClassPrepare (env, jni_env, event_thread, klass); + } + break; + + case JVMTI_EVENT_VM_START: + if (env->callbacks.VMStart != NULL) + { + ARG (JNIEnv *, jni_env); + env->callbacks.VMStart (env, jni_env); + } + break; + + case JVMTI_EVENT_EXCEPTION: + if (env->callbacks.Exception != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + ARG (jobject, exception); + ARG (jmethodID, catch_method); + ARG (jlocation, catch_location); + env->callbacks.Exception (env, jni_env, event_thread, method, + location, exception, catch_method, + catch_location); + } + break; + + case JVMTI_EVENT_EXCEPTION_CATCH: + if (env->callbacks.ExceptionCatch != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + ARG (jobject, exception); + env->callbacks.ExceptionCatch (env, jni_env, event_thread, method, + location, exception); + } + break; + + case JVMTI_EVENT_SINGLE_STEP: + if (env->callbacks.SingleStep != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + env->callbacks.SingleStep (env, jni_env, event_thread, method, + location); + } + break; + + case JVMTI_EVENT_FRAME_POP: + if (env->callbacks.FramePop != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + GET_BOOLEAN_ARG (was_popped_by_exception); + env->callbacks.FramePop (env, jni_env, event_thread, method, + was_popped_by_exception); + } + break; + + case JVMTI_EVENT_BREAKPOINT: + if (env->callbacks.Breakpoint != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + env->callbacks.Breakpoint (env, jni_env, event_thread, method, + location); + } + break; + + case JVMTI_EVENT_FIELD_ACCESS: + if (env->callbacks.FieldAccess != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + ARG (jclass, field_class); + ARG (jobject, object); + ARG (jfieldID, field); + env->callbacks.FieldAccess (env, jni_env, event_thread, method, + location, field_class, object, field); + } + break; + + case JVMTI_EVENT_FIELD_MODIFICATION: + if (env->callbacks.FieldModification != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (jlocation, location); + ARG (jclass, field_class); + ARG (jobject, object); + ARG (jfieldID, field); + GET_CHAR_ARG (signature_type); + ARG (jvalue, new_value); + env->callbacks.FieldModification (env, jni_env, event_thread, method, + location, field_class, object, + field, signature_type, new_value); + } + break; + + case JVMTI_EVENT_METHOD_ENTRY: + if (env->callbacks.MethodEntry != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + env->callbacks.MethodEntry (env, jni_env, event_thread, method); + } + break; + + case JVMTI_EVENT_METHOD_EXIT: + if (env->callbacks.MethodExit != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + GET_BOOLEAN_ARG (was_popped_by_exception); + ARG (jvalue, return_value); + env->callbacks.MethodExit (env, jni_env, event_thread, method, + was_popped_by_exception, return_value); + } + break; + + case JVMTI_EVENT_NATIVE_METHOD_BIND: + if (env->callbacks.NativeMethodBind != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jmethodID, method); + ARG (void *, address); + ARG (void **, new_address_ptr); + env->callbacks.NativeMethodBind (env, jni_env, event_thread, method, + address, new_address_ptr); + } + break; + + case JVMTI_EVENT_COMPILED_METHOD_LOAD: + if (env->callbacks.CompiledMethodLoad != NULL) + { + ARG (jmethodID, method); + ARG (jint, code_size); + ARG (const void *, code_addr); + ARG (jint, map_length); + ARG (const jvmtiAddrLocationMap *, map); + ARG (const void *, compile_info); + env->callbacks.CompiledMethodLoad (env, method, code_size, code_addr, + map_length, map, compile_info); + } + break; + + case JVMTI_EVENT_COMPILED_METHOD_UNLOAD: + if (env->callbacks.CompiledMethodUnload != NULL) + { + ARG (jmethodID, method); + ARG (const void *, code_addr); + env->callbacks.CompiledMethodUnload (env, method, code_addr); + } + break; + + case JVMTI_EVENT_DYNAMIC_CODE_GENERATED: + if (env->callbacks.DynamicCodeGenerated != NULL) + { + ARG (const char *, name); + ARG (const void *, address); + ARG (jint, length); + env->callbacks.DynamicCodeGenerated (env, name, address, length); + } + break; + + case JVMTI_EVENT_DATA_DUMP_REQUEST: + if (env->callbacks.DataDumpRequest != NULL) + { + env->callbacks.DataDumpRequest (env); + } + break; + + case JVMTI_EVENT_MONITOR_WAIT: + if (env->callbacks.MonitorWait != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jobject, object); + ARG (jlong, timeout); + env->callbacks.MonitorWait (env, jni_env, event_thread, object, + timeout); + } + break; + + case JVMTI_EVENT_MONITOR_WAITED: + if (env->callbacks.MonitorWaited != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jobject, object); + GET_BOOLEAN_ARG (timed_out); + env->callbacks.MonitorWaited (env, jni_env, event_thread, object, + timed_out); + } + break; + + case JVMTI_EVENT_MONITOR_CONTENDED_ENTER: + if (env->callbacks.MonitorContendedEnter != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jobject, object); + env->callbacks.MonitorContendedEnter (env, jni_env, event_thread, + object); + } + break; + + case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED: + if (env->callbacks.MonitorContendedEntered != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jobject, object); + env->callbacks.MonitorContendedEntered (env, jni_env, event_thread, + object); + } + break; + + case JVMTI_EVENT_GARBAGE_COLLECTION_START: + if (env->callbacks.GarbageCollectionStart != NULL) + { + env->callbacks.GarbageCollectionStart (env); + } + break; + + case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH: + if (env->callbacks.GarbageCollectionFinish != NULL) + { + env->callbacks.GarbageCollectionFinish (env); + } + break; + + case JVMTI_EVENT_OBJECT_FREE: + if (env->callbacks.ObjectFree != NULL) + { + ARG (jlong, tag); + env->callbacks.ObjectFree (env, tag); + } + break; + + case JVMTI_EVENT_VM_OBJECT_ALLOC: + if (env->callbacks.VMObjectAlloc != NULL) + { + ARG (JNIEnv *, jni_env); + ARG (jobject, object); + ARG (jclass, object_class); + ARG (jlong, size); + env->callbacks.VMObjectAlloc (env, jni_env, event_thread, + object, object_class, size); + } + break; + + default: + fprintf (stderr, "libgcj: post of unknown JVMTI event (%d)\n", + (int) type); + break; + } + va_end (args); +#undef ARG +#undef GET_BOOLEAN_ARG +#undef GET_CHAR_ARG +} + +/* Post an event to requesting JVMTI environments + * + * This function should not be called without consulting the + * JVMTI_REQUESTED_EVENT macro first (for speed). It does no real + * harm (other than kill speed), since this function will still + * only send the event if it was properly requested by an environment. + */ +void +_Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...) +{ + va_list args; + va_start (args, event_thread); + + JvSynchronize dummy (_envListLock); + struct jvmti_env_list *e; + FOREACH_ENVIRONMENT (e) + { + /* Events are only posted if the event was explicitly enabled, + it has a registered event handler, and the event thread + matches (either globally or restricted to a specific thread). + Here we check all but the event handler, which will be handled + by post_event. */ + if (e->env->enabled[EVENT_INDEX(type)] + && (e->env->thread[EVENT_INDEX(type)] == NULL + || e->env->thread[EVENT_INDEX(type)] == event_thread)) + { + post_event (e->env, type, event_thread, args); + } + } + + va_end (args); } diff --git a/libjava/testsuite/libjava.jvmti/events.java b/libjava/testsuite/libjava.jvmti/events.java new file mode 100644 index 0000000..05deeeb --- /dev/null +++ b/libjava/testsuite/libjava.jvmti/events.java @@ -0,0 +1,12 @@ +// Test JVMTI event notifications + +public class events +{ + public static native void do_events_tests (); + + public static void main (String[] args) + { + System.out.println ("JVMTI event notification tests"); + do_events_tests (); + } +} diff --git a/libjava/testsuite/libjava.jvmti/events.out b/libjava/testsuite/libjava.jvmti/events.out new file mode 100644 index 0000000..0f6c0b0 --- /dev/null +++ b/libjava/testsuite/libjava.jvmti/events.out @@ -0,0 +1,59 @@ +JVMTI event notification tests +- enable tests - +created JVMTI environment #0 +created JVMTI environment #1 +created JVMTI environment #2 +setting callbacks for envs +RequestedEvents: +enable VM_INIT for env0, env1, env2 +RequestedEvents: VMInit, +enable VM_DEATH for env1,env2 +RequestedEvents: VMInit,VMDeath, +enable THREAD_END for env2 +RequestedEvents: VMInit,VMDeath,ThreadEnd, +disposing of env1 +RequestedEvents: VMInit,VMDeath,ThreadEnd, +disposing of env0 +RequestedEvents: VMInit,VMDeath,ThreadEnd, +disable VMInit in env2 +RequestedEvents: VMDeath,ThreadEnd, +clear VMDeath callback in env2 +RequestedEvents: ThreadEnd, +sending VMInit +sending ThreadEnd +ThreadEndCB jni_env=0x5678 thread=0x1234 +sending VMDeath +disposing of env2 +RequestedEvents: +- callback arg tests - +RequestedEvents: VMInit,VMDeath,ThreadStart,ThreadEnd,ClassFileLoadHook,ClassLoad,ClassPrepare,VMStart,Exception,ExceptionCatch,SingleStep,FramePop,Breakpoint,FieldAccess,FieldModification,MethodEntry,MethodExit,NativeMethodBind,CompiledMethodLoad,CompiledMethodUnload,DynamicCodeGenerated,DataDumpRequest,MonitorWait,MonitorWaited,MonitorContendedEnter,MonitorContendedEntered,GarbageCollectionStart,GarbageCollectionFinish,ObjectFree,VMObjectAlloc, +VMInitCB jni_env=0x1 thread=0x2 +VMDeathCB jni_env=0x1 +ThreadStartCB jni_env=0x1 thread=0x2 +ThreadEndCB jni_env=0x1 thread=0x2 +ClassFileLoadHookCB jni_env=0x1 class_being_redefined=0x2 loader=0x3 name=4 protection_domain=0x5 class_data_len=6 class_data=0x7 new_class_data_len=0x8 new_class_data=0x9 +ClassLoadCB jni_env=0x1 thread=0x2 klass=0x3 +ClassPrepareCB jni_env=0x1 thread=0x2 klass=0x3 +VMStartCB jni_env=0x1 +ExceptionCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 exception=0x5 catch_method=0x6 catch_location=0x7 +ExceptionCatchCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 exception=0x5 +SingleStepCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 +FramePopCB jni_env=0x1 thread=0x2 method=0x3 was_pooped_by_exception=1 +BreakpointCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 +FieldAccessCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 field_klass=0x5 object=0x6 field=0x7 +FieldModificationCB jni_env=0x1 thread=0x2 method=0x3 location=0x4 field_klass=0x5 object=0x6 field=0x7 signature_type=8 new_value=9 +MethodEntryCB jni_env=0x1 thread=0x2 method=0x3 +MethodExitCB jni_env=0x1 thread=0x2 method=0x3 was_popped_by_exception=1 return_value=5 +NativeMethodBindCB jni_env=0x1 thread=0x2 method=0x3 address=0x4 new_address_ptr=0x5 +CompiledMethodLoadCB method=0x1 code_size=0x2 code_addr=0x3 map_length=4 map=0x5 compile_info=0x6 +CompiledMethodUnloadCB method=0x1 code_addr=0x2 +DynamicCodeGeneratedCB name=1 address=0x2 length=3 +DataDumpRequestCB +MonitorWaitCB jni_env=0x1 thread=0x2 object=0x3 timeout=4 +MonitorWaitedCB jni_env=0x1 thread=0x2 object=0x3 timed_out=1 +MonitorContendedEnterCB jni_env=0x1 thread=0x2 object=0x3 +MonitorContendedEnteredCB jni_env=0x1 thread=0x2 object=0x3 +GarbageCollectionStartCB +GarbageCollectionFinishCB +ObjectFreeCB tag=1 +VMObjectAllocCB jni_env=0x1 thread=0x2 object=0x3 object_klass=0x4 size=5 diff --git a/libjava/testsuite/libjava.jvmti/natevents.cc b/libjava/testsuite/libjava.jvmti/natevents.cc new file mode 100644 index 0000000..d5720bb --- /dev/null +++ b/libjava/testsuite/libjava.jvmti/natevents.cc @@ -0,0 +1,544 @@ +#include + +#include +#include +#include + +#include "jvmti-int.h" +#include "events.h" + +static jvmtiEnv *env = NULL; + +void +print_events () +{ +#define DO(X) \ + do \ + { \ + if (JVMTI_REQUESTED_EVENT (X)) \ + printf (#X ","); \ + } \ + while (0) + + printf ("RequestedEvents: "); + DO (VMInit); + DO (VMDeath); + DO (ThreadStart); + DO (ThreadEnd); + DO (ClassFileLoadHook); + DO (ClassLoad); + DO (ClassPrepare); + DO (VMStart); + DO (Exception); + DO (ExceptionCatch); + DO (SingleStep); + DO (FramePop); + DO (Breakpoint); + DO (FieldAccess); + DO (FieldModification); + DO (MethodEntry); + DO (MethodExit); + DO (NativeMethodBind); + DO (CompiledMethodLoad); + DO (CompiledMethodUnload); + DO (DynamicCodeGenerated); + DO (DataDumpRequest); + DO (MonitorWait); + DO (MonitorWaited); + DO (MonitorContendedEnter); + DO (MonitorContendedEntered); + DO (GarbageCollectionStart); + DO (GarbageCollectionFinish); + DO (ObjectFree); + DO (VMObjectAlloc); + printf ("\n"); +#undef DO +} + +static void +VMInitCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread) +{ + printf ("VMInitCB jni_env=%p thread=%p\n", jni_env, thread); +} + +static void +VMDeathCB (jvmtiEnv *env, JNIEnv *jni_env) +{ + printf ("VMDeathCB jni_env=%p\n", jni_env); +} + +static void +ThreadStartCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread) +{ + printf ("ThreadStartCB jni_env=%p thread=%p\n", jni_env, thread); +} + +static void +ThreadEndCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread) +{ + printf ("ThreadEndCB jni_env=%p thread=%p\n", jni_env, thread); +} + +static void +ClassFileLoadHookCB (jvmtiEnv *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) +{ + printf ("ClassFileLoadHookCB jni_env=%p class_being_redefined=%p loader=%p", + jni_env, class_being_redefined, loader); + printf (" name=%s protection_domain=%p class_data_len=%d class_data=%p", + name, protection_domain, (int) class_data_len, class_data); + printf (" new_class_data_len=%p new_class_data=%p\n", new_class_data_len, + new_class_data); +} + +static void +ClassLoadCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jclass klass) +{ + printf ("ClassLoadCB jni_env=%p thread=%p klass=%p\n", jni_env, thread, + klass); +} + +static void +ClassPrepareCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jclass klass) +{ + printf ("ClassPrepareCB jni_env=%p thread=%p klass=%p\n", jni_env, + thread, klass); +} + +static void +VMStartCB (jvmtiEnv *env, JNIEnv *jni_env) +{ + printf ("VMStartCB jni_env=%p\n", jni_env); +} + +static void +ExceptionCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method, + jlocation location, jobject exception, jmethodID catch_method, + jlocation catch_location) +{ + printf ("ExceptionCB jni_env=%p thread=%p method=%p location=%p", jni_env, + thread, method, location); + printf (" exception=%p catch_method=%p catch_location=%p\n", exception, + catch_method, catch_location); +} + +static void +ExceptionCatchCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method, jlocation location, jobject exception) +{ + printf ("ExceptionCatchCB jni_env=%p thread=%p method=%p location=%p", + jni_env, thread, method, location); + printf (" exception=%p\n", exception); +} + +static void +SingleStepCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method, + jlocation location) +{ + printf ("SingleStepCB jni_env=%p thread=%p method=%p location=%p\n", + jni_env, thread, method, location); +} + +static void +FramePopCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method, + jboolean was_popped_by_exception) +{ + printf ("FramePopCB jni_env=%p thread=%p method=%p", jni_env, thread, + method); + printf (" was_pooped_by_exception=%d\n", (was_popped_by_exception ? + 1 : 0)); +} + +static void +BreakpointCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method, + jlocation location) +{ + printf ("BreakpointCB jni_env=%p thread=%p method=%p location=%p\n", + jni_env, thread, method, location); +} + +static void +FieldAccessCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method, jlocation location, jclass field_klass, + jobject object, jfieldID field) +{ + printf ("FieldAccessCB jni_env=%p thread=%p method=%p location=%p", + jni_env, thread, method, location); + printf (" field_klass=%p object=%p field=%p\n", field_klass, object, field); +} + +static void +FieldModificationCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method, jlocation location, jclass field_klass, + jobject object, jfieldID field, char signature_type, + jvalue new_value) + +{ + printf ("FieldModificationCB jni_env=%p thread=%p method=%p location=%p", + jni_env, thread, method, location); + printf (" field_klass=%p object=%p field=%p signature_type=%c", field_klass, + object, field, signature_type); + printf (" new_value=%d\n", (int) new_value.i); +} + +static void +MethodEntryCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method) +{ + printf ("MethodEntryCB jni_env=%p thread=%p method=%p\n", jni_env, thread, + method); +} + +static void +MethodExitCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method, jboolean was_popped_by_exception, + jvalue return_value) +{ + printf ("MethodExitCB jni_env=%p thread=%p method=%p", jni_env, thread, + method); + printf (" was_popped_by_exception=%d return_value=%d\n", + (was_popped_by_exception) ? 1 : 0, (int) return_value.i); +} + +static void +NativeMethodBindCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jmethodID method, void *address, void **new_address_ptr) +{ + printf ("NativeMethodBindCB jni_env=%p thread=%p method=%p", jni_env, + thread, method); + printf (" address=%p new_address_ptr=%p\n", address, new_address_ptr); +} + +static void +CompiledMethodLoadCB (jvmtiEnv *env, jmethodID method, jint code_size, + const void *code_addr, jint map_length, + const jvmtiAddrLocationMap *map, + const void *compile_info) +{ + printf ("CompiledMethodLoadCB method=%p code_size=%p code_addr=%p", + method, code_size, code_addr); + printf (" map_length=%d map=%p compile_info=%p\n", (int) map_length, map, + compile_info); +} + +static void +CompiledMethodUnloadCB (jvmtiEnv *env, jmethodID method, const void *code_addr) +{ + printf ("CompiledMethodUnloadCB method=%p code_addr=%p\n", method, + code_addr); +} + +static void +DynamicCodeGeneratedCB (jvmtiEnv *env, const char *name, const void *address, + jint length) +{ + printf ("DynamicCodeGeneratedCB name=%s address=%p length=%d\n", name, + address, (int) length); +} + +static void +DataDumpRequestCB (jvmtiEnv *env) +{ + printf ("DataDumpRequestCB\n"); +} + +static void +MonitorWaitCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jobject object, + jlong timeout) +{ + printf ("MonitorWaitCB jni_env=%p thread=%p object=%p timeout=%ld\n", + jni_env, thread, object, (long) timeout); +} + +static void +MonitorWaitedCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jobject object, jboolean timed_out) +{ + printf ("MonitorWaitedCB jni_env=%p thread=%p object=%p timed_out=%d\n", + jni_env, thread, object, (timed_out) ? 1 : 0); +} + +static void +MonitorContendedEnterCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jobject object) +{ + printf ("MonitorContendedEnterCB jni_env=%p thread=%p object=%p\n", + jni_env, thread, object); +} + +static void +MonitorContendedEnteredCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jobject object) +{ + printf ("MonitorContendedEnteredCB jni_env=%p thread=%p object=%p\n", + jni_env, thread, object); +} + +static void +GarbageCollectionStartCB (jvmtiEnv *env) +{ + printf ("GarbageCollectionStartCB\n"); +} + +static void +GarbageCollectionFinishCB (jvmtiEnv *env) +{ + printf ("GarbageCollectionFinishCB\n"); +} + +static void +ObjectFreeCB (jvmtiEnv *env, jlong tag) +{ + printf ("ObjectFreeCB tag=%ld\n", (long) tag); +} + +static void +VMObjectAllocCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, + jobject object, jclass object_klass, jlong size) +{ + printf ("VMObjectAllocCB jni_env=%p thread=%p object=%p", jni_env, + thread, object); + printf (" object_klass=%p size=%ld\n", object_klass, (long) size); +} + +static void +do_enable_tests () +{ + printf ("- enable tests -\n"); + JavaVM *vm = _Jv_GetJavaVM (); + jvmtiEnv *env[3]; + int i; + for (i = 0; i < 3; ++i) + { + vm->GetEnv (reinterpret_cast (&env[i]), JVMTI_VERSION_1_0); + printf ("created JVMTI environment #%d\n", i); + } + + jvmtiEventCallbacks callbacks; + memset (&callbacks, 0, sizeof (jvmtiEventCallbacks)); + + printf ("setting callbacks for envs\n"); + callbacks.VMInit = VMInitCB; + env[0]->SetEventCallbacks (&callbacks, sizeof (callbacks)); + callbacks.VMDeath = VMDeathCB; + env[1]->SetEventCallbacks (&callbacks, sizeof (callbacks)); + callbacks.ThreadEnd = ThreadEndCB; + env[2]->SetEventCallbacks (&callbacks, sizeof (callbacks)); + print_events (); + + printf ("enable VM_INIT for env0, env1, env2\n"); + env[0]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL); + env[1]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL); + env[2]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL); + print_events (); + + printf ("enable VM_DEATH for env1,env2\n"); + env[1]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL); + env[2]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL); + print_events (); + + /* Used to use a non-NULL event thread, but that causes problems + when SetEventNotificationMode tries to validate the thread. */ + printf ("enable THREAD_END for env2\n"); + env[2]->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_THREAD_END, + NULL); + print_events (); + + printf ("disposing of env1\n"); + env[1]->DisposeEnvironment (); + print_events (); + + printf ("disposing of env0\n"); + env[0]->DisposeEnvironment (); + print_events (); + + printf ("disable VMInit in env2\n"); + env[2]->SetEventNotificationMode (JVMTI_DISABLE, JVMTI_EVENT_VM_INIT, NULL); + print_events (); + + printf ("clear VMDeath callback in env2\n"); + callbacks.VMDeath = NULL; + env[2]->SetEventCallbacks (&callbacks, sizeof (callbacks)); + print_events (); + + printf ("sending VMInit\n"); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_INIT, (jthread) 0x1234, + (JNIEnv *) 0x5678); + + printf ("sending ThreadEnd\n"); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_END, (jthread) 0x1234, + (JNIEnv *) 0x5678); + + /* See comment above re: SetEventNotificationMode and validity + checking + printf ("sending ThreadEnd (no match)\n"); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_END, (jthread) 0x4321, + (JNIEnv *) 0x5678); + */ + + printf ("sending VMDeath\n"); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_DEATH, (jthread) NULL, + (JNIEnv *) 0x5678); + + printf ("disposing of env2\n"); + env[2]->DisposeEnvironment (); + print_events (); +} + +static void +do_callback_arg_tests () +{ + printf ("- callback arg tests -\n"); + JavaVM *vm = _Jv_GetJavaVM (); + jvmtiEnv *env; + vm->GetEnv (reinterpret_cast (&env), JVMTI_VERSION_1_0); + + // Define all the callbacks +#define DEFINE(Event) callbacks.Event = Event ## CB; + jvmtiEventCallbacks callbacks; + DEFINE(VMInit); + DEFINE(VMDeath); + DEFINE(ThreadStart); + DEFINE(ThreadEnd); + DEFINE(ClassFileLoadHook); + DEFINE(ClassLoad); + DEFINE(ClassPrepare); + DEFINE(VMStart); + DEFINE(Exception); + DEFINE(ExceptionCatch); + DEFINE(SingleStep); + DEFINE(FramePop); + DEFINE(Breakpoint); + DEFINE(FieldAccess); + DEFINE(FieldModification); + DEFINE(MethodEntry); + DEFINE(MethodExit); + DEFINE(NativeMethodBind); + DEFINE(CompiledMethodLoad); + DEFINE(CompiledMethodUnload); + DEFINE(DynamicCodeGenerated); + DEFINE(DataDumpRequest); + DEFINE(MonitorWait); + DEFINE(MonitorWaited); + DEFINE(MonitorContendedEnter); + DEFINE(MonitorContendedEntered); + DEFINE(GarbageCollectionStart); + DEFINE(GarbageCollectionFinish); + DEFINE(ObjectFree); + DEFINE(VMObjectAlloc); +#undef DEFINE + env->SetEventCallbacks (&callbacks, sizeof (callbacks)); + + // Enable all the callbacks +#define ENABLE(Event) \ + env->SetEventNotificationMode (JVMTI_ENABLE, JVMTI_EVENT_ ## Event, NULL) + ENABLE (VM_INIT); + ENABLE (VM_DEATH); + ENABLE (THREAD_START); + ENABLE (THREAD_END); + ENABLE (CLASS_FILE_LOAD_HOOK); + ENABLE (CLASS_LOAD); + ENABLE (CLASS_PREPARE); + ENABLE (VM_START); + ENABLE (EXCEPTION); + ENABLE (EXCEPTION_CATCH); + ENABLE (SINGLE_STEP); + ENABLE (FRAME_POP); + ENABLE (BREAKPOINT); + ENABLE (FIELD_ACCESS); + ENABLE (FIELD_MODIFICATION); + ENABLE (METHOD_ENTRY); + ENABLE (METHOD_EXIT); + ENABLE (NATIVE_METHOD_BIND); + ENABLE (COMPILED_METHOD_LOAD); + ENABLE (COMPILED_METHOD_UNLOAD); + ENABLE (DYNAMIC_CODE_GENERATED); + ENABLE (DATA_DUMP_REQUEST); + ENABLE (MONITOR_WAIT); + ENABLE (MONITOR_WAITED); + ENABLE (MONITOR_CONTENDED_ENTER); + ENABLE (MONITOR_CONTENDED_ENTERED); + ENABLE (GARBAGE_COLLECTION_START); + ENABLE (GARBAGE_COLLECTION_FINISH); + ENABLE (OBJECT_FREE); + ENABLE (VM_OBJECT_ALLOC); + + // All events should now be enabled. + print_events (); + + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_INIT, (jthread) 0x2, (JNIEnv *) 0x1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_DEATH, (jthread) 0x2, (JNIEnv *) 0x1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_START, (jthread) 0x2, + (JNIEnv *) 0x1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_END, (jthread) 0x2, + (JNIEnv *) 0x1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, (jthread) 0xb00, + (JNIEnv *) 0x1, (jclass) 0x2, (jobject) 0x3, + "4", (jobject) 0x5, (jint) 6, + (const unsigned char *) 0x7, (jint *) 0x8, + (unsigned char **) 0x9); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_CLASS_LOAD, (jthread) 0x2, (JNIEnv *) 0x1, + (jclass) 0x3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_CLASS_PREPARE, (jthread) 0x2, + (JNIEnv *) 0x1, (jclass) 0x3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_START, (jthread) 0xb00, (JNIEnv *) 0x1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_EXCEPTION, (jthread) 0x2, (JNIEnv *) 0x1, + (jmethodID) 0x3, (jlocation) 0x4, (jobject) 0x5, + (jmethodID) 0x6, (jlocation) 0x7); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_EXCEPTION_CATCH, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3, (jlocation) 0x4, + (jobject) 0x5); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_SINGLE_STEP, (jthread) 0x2, (JNIEnv *) 0x1, + (jmethodID) 0x3, (jlocation) 0x4); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_FRAME_POP, (jthread) 0x2, (JNIEnv *) 0x1, + (jmethodID) 0x3, 4); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_BREAKPOINT, (jthread) 0x2, (JNIEnv *) 0x1, + (jmethodID) 0x3, (jlocation) 0x4); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_FIELD_ACCESS, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3, (jlocation) 0x4, + (jclass) 0x5, (jobject) 0x6, (jfieldID) 0x7); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_FIELD_MODIFICATION, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3, (jlocation) 0x4, + (jclass) 0x5, (jobject) 0x6, (jfieldID) 0x7, + (int) '8', (/*jvalue*/ jobject) 0x9); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_METHOD_ENTRY, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_METHOD_EXIT, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3, 4, /*jvalue*/ 5); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_NATIVE_METHOD_BIND, (jthread) 0x2, + (JNIEnv *) 0x1, (jmethodID) 0x3, (void *) 0x4, + (void **) 0x5); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_COMPILED_METHOD_LOAD, (jthread) 0xb00, + (jmethodID) 0x1, (jint) 2, (const void *) 0x3, + (jint) 4, (const jvmtiAddrLocationMap *) 0x5, + (const void *) 0x6); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_COMPILED_METHOD_UNLOAD, (jthread) 0xb00, + (jmethodID) 0x1, (const void *) 0x2); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_DYNAMIC_CODE_GENERATED, (jthread) 0xb00, + "1", (const void *) 0x2, (jint) 3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_DATA_DUMP_REQUEST, (jthread) 0xb00); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_MONITOR_WAIT, (jthread) 0x2, + (JNIEnv *) 0x1, (jobject) 0x3, (jlong) 4); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_MONITOR_WAITED, (jthread) 0x2, + (JNIEnv *) 0x1, (jobject) 0x3, (int) 4); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_MONITOR_CONTENDED_ENTER, (jthread) 0x2, + (JNIEnv *) 0x1, (jobject) 0x3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, (jthread) 0x2, + (JNIEnv *) 0x1, (jobject) 0x3); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_GARBAGE_COLLECTION_START, (jthread) 0xb00); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, (jthread) 0xb00); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_OBJECT_FREE, (jthread) 0xb00, (jlong) 1); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_VM_OBJECT_ALLOC, (jthread) 0x2, + (JNIEnv *) 0x1, (jobject) 0x3, (jclass) 0x4, + (jlong) 5); +} + +void +events::do_events_tests () +{ + do_enable_tests (); + do_callback_arg_tests (); +} -- cgit v1.1