obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 578 insertions, 0 deletions

diff --git a/libjava/testsuite/libjava.jvmti/natevents.cc b/libjava/testsuite/libjava.jvmti/natevents.cc
new file mode 100644
index 000000000..71c6489d8
--- /dev/null
+++ b/libjava/testsuite/libjava.jvmti/natevents.cc
@@ -0,0 +1,578 @@
+#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=%#llx\n", (unsigned long long) new_value.l);
+}
+
+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 ();
+}