Re: [RFA/JVMTI] SetEventNotificationMode and SetEventCallbacks

[Keith Seitz <keiths at redhat dot com>]

Tom Tromey wrote:

> Keith> +/* A global bit field to help limit the impact of JVMTI on normal
> Keith> +   operations. Unset fields (events) mean no JVMTI environment requested
> Keith> +   that event type. */
>
> A couple questions here.
>
> One is, do we really want a bit field?  I'm concerned that some events
> will occur in places where we really want to be cycle-shaving, perhaps
> plain booleans would be better.
>
> The other is, would a namespace be "more C++-like"?

That hadn't occurred to me. I'll do that instead. Thanks!!

> Keith> +/* A macro to test whether an event should be posted to JVMTI.*/
> Keith> +#define JVMTI_REQUESTED_EVENT(Event) (_Jv_JVMTI_RequestedEvents.Event == 1)
>
> Perhaps this should be wrapped in __builtin_expect, and expect 'no'.

[You mean 'false'?] Done.

> Keith> +#define CHECK_EVENT(Event)
>
> Avoiding a bit-field would let you simplify this code somewhat.  Not
> that it matters much, I suppose, but this code could then be
> parameterized by field offset or by pointer-to-global, instead of
> having a loop in each branch of the switch.

Hmm. Yeah, I suppose I could do something like that. Although I've 
tested this quite a bit, I'm not entirely sure the new cast in this 
function (check_enabled_event) is legal. Alas, gcc doesn't give any 
warnings on this. Could you please scrutinize this?

Keith

Index: include/jvmti_md.h
===================================================================
--- include/jvmti_md.h	(revision 116609)
+++ include/jvmti_md.h	(working copy)
@@ -27,6 +27,32 @@
 #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__ */
Index: include/jvmti-int.h
===================================================================
--- include/jvmti-int.h	(revision 0)
+++ include/jvmti-int.h	(revision 0)
@@ -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__ */
Index: jvmti.cc
===================================================================
--- jvmti.cc	(revision 116636)
+++ jvmti.cc	(working copy)
@@ -15,6 +15,7 @@
 #include <java-threads.h>
 #include <java-gc.h>
 #include <jvmti.h>
+#include "jvmti-int.h"
 
 #include <gcj/method.h>
 
@@ -32,6 +33,9 @@
 #include <java/util/HashMap.h>
 #include <java/net/URL.h>
 
+static void check_enabled_events (void);
+static void check_enabled_event (jvmtiEvent);
+
 extern struct JNINativeInterface _Jv_JNIFunctions;
 
 struct _Jv_rawMonitorID
@@ -505,6 +509,9 @@
     }
 
   _Jv_Free (env);
+
+  check_enabled_events ();
+
   return JVMTI_ERROR_NONE;
 }
 
@@ -649,13 +656,390 @@
   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;
+
+  switch (type)
+    {
+    case JVMTI_EVENT_VM_INIT:
+      enabled = &JVMTI::VMInit;
+      break;
+
+    case JVMTI_EVENT_VM_DEATH:
+      enabled = &JVMTI::VMDeath;
+      break;
+
+    case JVMTI_EVENT_THREAD_START:
+      enabled = &JVMTI::ThreadStart;
+      break;
+
+    case JVMTI_EVENT_THREAD_END:
+      enabled = &JVMTI::ThreadEnd;
+      break;
+
+    case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
+      enabled = &JVMTI::ClassFileLoadHook;
+      break;
+
+    case JVMTI_EVENT_CLASS_LOAD:
+      enabled = &JVMTI::ClassLoad;
+      break;
+
+    case JVMTI_EVENT_CLASS_PREPARE:
+      enabled = &JVMTI::ClassPrepare;
+      break;
+
+    case JVMTI_EVENT_VM_START:
+      enabled = &JVMTI::VMStart;
+      break;
+
+    case JVMTI_EVENT_EXCEPTION:
+      enabled = &JVMTI::Exception;
+      break;
+
+    case JVMTI_EVENT_EXCEPTION_CATCH:
+      enabled = &JVMTI::ExceptionCatch;
+      break;
+
+    case JVMTI_EVENT_SINGLE_STEP:
+      enabled = &JVMTI::SingleStep;
+      break;
+
+    case JVMTI_EVENT_FRAME_POP:
+      enabled = &JVMTI::FramePop;
+      break;
+
+    case JVMTI_EVENT_BREAKPOINT:
+      enabled = &JVMTI::Breakpoint;
+      break;
+
+    case JVMTI_EVENT_FIELD_ACCESS:
+      enabled = &JVMTI::FieldAccess;
+      break;
+
+    case JVMTI_EVENT_FIELD_MODIFICATION:
+      enabled = &JVMTI::FieldModification;
+      break;
+
+    case JVMTI_EVENT_METHOD_ENTRY:
+      enabled = &JVMTI::MethodEntry;
+      break;
+
+    case JVMTI_EVENT_METHOD_EXIT:
+      enabled = &JVMTI::MethodExit;
+      break;
+
+    case JVMTI_EVENT_NATIVE_METHOD_BIND:
+      enabled = &JVMTI::NativeMethodBind;
+      break;
+
+    case JVMTI_EVENT_COMPILED_METHOD_LOAD:
+      enabled = &JVMTI::CompiledMethodLoad;
+      break;
+
+    case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
+      enabled = &JVMTI::CompiledMethodUnload;
+      break;
+
+    case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
+      enabled = &JVMTI::DynamicCodeGenerated;
+      break;
+
+    case JVMTI_EVENT_DATA_DUMP_REQUEST:
+      enabled = &JVMTI::DataDumpRequest;
+      break;
+
+    case JVMTI_EVENT_MONITOR_WAIT:
+      enabled = &JVMTI::MonitorWait;
+      break;
+
+    case JVMTI_EVENT_MONITOR_WAITED:
+      enabled = &JVMTI::MonitorWaited;
+      break;
+
+    case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
+      enabled = &JVMTI::MonitorContendedEnter;
+      break;
+
+    case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
+      enabled = &JVMTI::MonitorContendedEntered;
+      break;
+
+    case JVMTI_EVENT_GARBAGE_COLLECTION_START:
+      enabled = &JVMTI::GarbageCollectionStart;
+      break;
+
+    case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
+      enabled = &JVMTI::GarbageCollectionFinish;
+      break;
+
+    case JVMTI_EVENT_OBJECT_FREE:
+      enabled = &JVMTI::ObjectFree;
+      break;
+
+    case JVMTI_EVENT_VM_OBJECT_ALLOC:
+      enabled = &JVMTI::VMObjectAlloc;
+      break;
+
+    default:
+      fprintf (stderr,
+	       "libgcj: check_enabled_event for unknown JVMTI event (%d)\n",
+	       (int) type);
+    }
+
+  int index = EVENT_INDEX (type);
+  struct jvmti_env_list *e;
+  FOREACH_ENVIRONMENT (e)
+    {
+      void (**callback)()
+	= reinterpret_cast<void (**)()> (&e->env->callbacks) + index;
+      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 (false && event_thread != NULL)
+    {
+      using namespace java::lang;
+      Thread *t = reinterpret_cast<Thread *> (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;
+    }
+
+#define RECORD_EVENT(Event)	/* arg not used */	\
+  do							\
+    {							\
+      env->thread[EVENT_INDEX(type)] = event_thread;	\
+      env->enabled[EVENT_INDEX(type)] = enabled;	\
+    }							\
+  while (0)
+
+  switch (type)
+    {
+    case JVMTI_EVENT_VM_INIT:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (VMInit);
+      break;
+
+    case JVMTI_EVENT_VM_DEATH:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (VMDeath);
+      break;
+
+    case JVMTI_EVENT_THREAD_START:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (ThreadStart);
+      break;
+
+    case JVMTI_EVENT_THREAD_END:
+      RECORD_EVENT (ThreadEnd);
+      break;
+
+    case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
+      RECORD_EVENT (ClassFileLoadHook);
+      break;
+
+    case JVMTI_EVENT_CLASS_LOAD:
+      RECORD_EVENT (ClassLoad);
+      break;
+
+    case JVMTI_EVENT_CLASS_PREPARE:
+      RECORD_EVENT (ClassPrepare);
+      break;
+
+    case JVMTI_EVENT_VM_START:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (VMStart);
+      break;
+
+    case JVMTI_EVENT_EXCEPTION:
+      RECORD_EVENT (Exception);
+      break;
+
+    case JVMTI_EVENT_EXCEPTION_CATCH:
+      RECORD_EVENT (ExceptionCatch);
+      break;
+
+    case JVMTI_EVENT_SINGLE_STEP:
+      RECORD_EVENT (SingleStep);
+      break;
+
+    case JVMTI_EVENT_FRAME_POP:
+      RECORD_EVENT (FramePop);
+      break;
+
+    case JVMTI_EVENT_BREAKPOINT:
+      RECORD_EVENT (Breakpoint);
+      break;
+
+    case JVMTI_EVENT_FIELD_ACCESS:
+      RECORD_EVENT (FieldAccess);
+      break;
+
+    case JVMTI_EVENT_FIELD_MODIFICATION:
+      RECORD_EVENT (FieldModification);
+      break;
+
+    case JVMTI_EVENT_METHOD_ENTRY:
+      RECORD_EVENT (MethodEntry);
+      break;
+
+    case JVMTI_EVENT_METHOD_EXIT:
+      RECORD_EVENT (MethodExit);
+      break;
+
+    case JVMTI_EVENT_NATIVE_METHOD_BIND:
+      RECORD_EVENT (NativeMethodBind);
+      break;
+
+    case JVMTI_EVENT_COMPILED_METHOD_LOAD:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (CompiledMethodLoad);
+      break;
+
+    case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (CompiledMethodUnload);
+      break;
+
+    case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (DynamicCodeGenerated);
+      break;
+
+    case JVMTI_EVENT_DATA_DUMP_REQUEST:
+      ILLEGAL_ARGUMENT (event_thread != NULL);
+      RECORD_EVENT (DataDumpRequest);
+      break;
+
+    case JVMTI_EVENT_MONITOR_WAIT:
+      RECORD_EVENT (MonitorWait);
+      break;
+
+    case JVMTI_EVENT_MONITOR_WAITED:
+      RECORD_EVENT (MonitorWaited);
+      break;
+
+    case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
+      RECORD_EVENT (MonitorContendedEnter);
+      break;
+
+    case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
+      RECORD_EVENT (MonitorContendedEntered);
+      break;
+
+    case JVMTI_EVENT_GARBAGE_COLLECTION_START:
+      RECORD_EVENT (GarbageCollectionStart);
+      break;
+
+    case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
+      RECORD_EVENT (GarbageCollectionFinish);
+      break;
+
+    case JVMTI_EVENT_OBJECT_FREE:
+      RECORD_EVENT (ObjectFree);
+      break;
+
+    case JVMTI_EVENT_VM_OBJECT_ALLOC:
+      RECORD_EVENT (VMObjectAlloc);
+      break;
+
+    default:
+      return JVMTI_ERROR_INVALID_EVENT_TYPE;
+    }
+
+  check_enabled_event (type);
+
+  return JVMTI_ERROR_NONE;
+#undef RECORD_EVENT
+}
+
+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;
+}
+
 #define RESERVED NULL
 #define UNIMPLEMENTED NULL
 
 struct _Jv_jvmtiEnv _Jv_JVMTI_Interface =
 {
   RESERVED,			// reserved1
-  UNIMPLEMENTED,		// SetEventNotification
+  _Jv_JVMTI_SetEventNotificationMode, // SetEventNotificationMode
   RESERVED,			// reserved3
   UNIMPLEMENTED,		// GetAllThreads
   _Jv_JVMTI_SuspendThread,	// SuspendThread
@@ -775,7 +1159,7 @@
   RESERVED,			// reserved119
   _Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable
   _Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable
-  UNIMPLEMENTED,		// SetEventCallbacks
+  _Jv_JVMTI_SetEventCallbacks,	// SetEventCallbacks
   UNIMPLEMENTED,		// GenerateEvents
   UNIMPLEMENTED,		// GetExtensionFunctions
   UNIMPLEMENTED,		// GetExtensionEvents
@@ -843,4 +1227,386 @@
 {
   _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, ...)
+{
+#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<char> (c)
+
+  va_list args;
+  va_start (args, event_thread);
+  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.MonitorContendedEnter (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);
+
+  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);
+}