gcc/libjava/testsuite/libjava.jvmti/natevents.cc

#include <gcj/cni.h>

#include <jvm.h>
#include <jvmti.h>
#include <stdio.h>

#include "jvmti-int.h"
#include "events.h"

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=%#llx thread=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread);
}

static void
VMDeathCB (jvmtiEnv *env, JNIEnv *jni_env)
{
  printf ("VMDeathCB jni_env=%#llx\n", (unsigned long long) jni_env);
}

static void
ThreadStartCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread)
{
  printf ("ThreadStartCB jni_env=%#llx thread=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread);
}

static void
ThreadEndCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread)
{
  printf ("ThreadEndCB jni_env=%#llx thread=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) 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=%#llx class_being_redefined=%#llx"
	  " loader=%#llx", (unsigned long long) jni_env, (unsigned long long)
	  class_being_redefined, (unsigned long long) loader);
  printf (" name=%s protection_domain=%#llx class_data_len=%d class_data=%#llx",
	  name, (unsigned long long) protection_domain, (int) class_data_len,
	  (unsigned long long) class_data);
  printf (" new_class_data_len=%#llx new_class_data=%#llx\n",
	  (unsigned long long) new_class_data_len, (unsigned long long)
	  new_class_data);
}

static void
ClassLoadCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jclass klass)
{
  printf ("ClassLoadCB jni_env=%#llx thread=%#llx klass=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) klass);
}

static void
ClassPrepareCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jclass klass)
{
  printf ("ClassPrepareCB jni_env=%#llx thread=%#llx klass=%#llx\n",
	  (unsigned long long)jni_env, (unsigned long long) thread,
	  (unsigned long long) klass);
}

static void
VMStartCB (jvmtiEnv *env, JNIEnv *jni_env)
{
  printf ("VMStartCB jni_env=%#llx\n", (unsigned long long) 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=%#llx thread=%#llx method=%#llx location=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) method, (unsigned long long) location);
  printf (" exception=%#llx catch_method=%#llx catch_location=%#llx\n",
	  (unsigned long long) exception, (unsigned long long) catch_method,
	  (unsigned long long) catch_location);
}

static void
ExceptionCatchCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread,
		  jmethodID method, jlocation location, jobject exception)
{
  printf ("ExceptionCatchCB jni_env=%#llx thread=%#llx method=%#llx"
	  " location=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) method, (unsigned long long) location);
  printf (" exception=%#llx\n", (unsigned long long) exception);
}

static void
SingleStepCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method,
	      jlocation location)
{
  printf ("SingleStepCB jni_env=%#llx thread=%#llx method=%#llx"
	  " location=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) method, (unsigned long long) location);
}

static void
FramePopCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread, jmethodID method,
	    jboolean was_popped_by_exception)
{
  printf ("FramePopCB jni_env=%#llx thread=%#llx method=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) 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=%#llx thread=%#llx method=%#llx"
	  " location=%#llx\n", (unsigned long long) jni_env,
	  (unsigned long long) thread, (unsigned long long) method,
	  (unsigned long long) 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=%#llx thread=%#llx method=%#llx"
	  " location=%#llx", (unsigned long long) jni_env, (unsigned long long)
	  thread, (unsigned long long) method, (unsigned long long) location);
  printf (" field_klass=%#llx object=%#llx field=%#llx\n", (unsigned long long)
	  field_klass, (unsigned long long) object, (unsigned long long) 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=%#llx thread=%#llx method=%#llx"
	  " location=%#llx", (unsigned long long) jni_env, (unsigned long long)
	  thread, (unsigned long long) method, (unsigned long long) location);
  printf (" field_klass=%#llx object=%#llx field=%#llx signature_type=%c",
	  (unsigned long long) field_klass, (unsigned long long) object,
	  (unsigned long long) 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=%#llx thread=%#llx method=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) 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=%#llx thread=%#llx method=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) 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=%#llx thread=%#llx method=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) method);
  printf (" address=%#llx new_address_ptr=%#llx\n", (unsigned long long)
	  address, (unsigned long long) 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=%#llx code_size=%#llx code_addr=%#llx",
	  (unsigned long long) method, (unsigned long long) code_size,
	  (unsigned long long) code_addr);
  printf (" map_length=%d map=%#llx compile_info=%#llx\n", (int) map_length,
	  (unsigned long long) map, (unsigned long long) compile_info);
}

static void
CompiledMethodUnloadCB (jvmtiEnv *env, jmethodID method, const void *code_addr)
{
  printf ("CompiledMethodUnloadCB method=%#llx code_addr=%#llx\n",
	  (unsigned long long) method, (unsigned long long) code_addr);
}

static void
DynamicCodeGeneratedCB (jvmtiEnv *env, const char *name, const void *address,
			jint length)
{
  printf ("DynamicCodeGeneratedCB name=%s address=%#llx length=%d\n", name,
	  (unsigned long long) 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=%#llx thread=%#llx object=%#llx timeout=%ld\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) object, (long) timeout);
}

static void
MonitorWaitedCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread,
		 jobject object, jboolean timed_out)
{
  printf ("MonitorWaitedCB jni_env=%#llx thread=%#llx object=%#llx"
	  " timed_out=%d\n", (unsigned long long) jni_env, (unsigned long long)
	  thread, (unsigned long long) object, (timed_out) ? 1 : 0);
}

static void
MonitorContendedEnterCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread,
			 jobject object)
{
  printf ("MonitorContendedEnterCB jni_env=%#llx thread=%#llx object=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) object);
}

static void
MonitorContendedEnteredCB (jvmtiEnv *env, JNIEnv *jni_env, jthread thread,
			   jobject object)
{
  printf ("MonitorContendedEnteredCB jni_env=%#llx thread=%#llx object=%#llx\n",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) 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=%#llx thread=%#llx object=%#llx",
	  (unsigned long long) jni_env, (unsigned long long) thread,
	  (unsigned long long) object);
  printf (" object_klass=%#llx size=%ld\n", (unsigned long long) 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<void **> (&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<void **> (&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);
  jvalue value;
  value.l = (jobject) 0x9;
  _Jv_JVMTI_PostEvent (JVMTI_EVENT_FIELD_MODIFICATION, (jthread) 0x2,
		       (JNIEnv *) 0x1, (jmethodID) 0x3, (jlocation) 0x4,
		       (jclass) 0x5, (jobject) 0x6, (jfieldID) 0x7,
		       (int) '8', value);
  _Jv_JVMTI_PostEvent (JVMTI_EVENT_METHOD_ENTRY, (jthread) 0x2,
		       (JNIEnv *) 0x1, (jmethodID) 0x3);
  jvalue value2;
  value2.i = 5;
  _Jv_JVMTI_PostEvent (JVMTI_EVENT_METHOD_EXIT, (jthread) 0x2,
		       (JNIEnv *) 0x1, (jmethodID) 0x3, 4, value2);
  _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 ();
}