1 // jvmti.cc - JVMTI implementation
3 /* Copyright (C) 2006, 2007 Free Software Foundation
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
15 #include <java-threads.h>
17 #include <java-interp.h>
19 #include "jvmti-int.h"
21 #include <gcj/method.h>
23 #include <gnu/classpath/SystemProperties.h>
24 #include <gnu/gcj/runtime/BootClassLoader.h>
25 #include <gnu/gcj/jvmti/Breakpoint.h>
26 #include <gnu/gcj/jvmti/BreakpointManager.h>
28 #include <java/lang/Class.h>
29 #include <java/lang/ClassLoader.h>
30 #include <java/lang/Object.h>
31 #include <java/lang/OutOfMemoryError.h>
32 #include <java/lang/Thread.h>
33 #include <java/lang/ThreadGroup.h>
34 #include <java/lang/Throwable.h>
35 #include <java/lang/VMClassLoader.h>
36 #include <java/lang/reflect/Field.h>
37 #include <java/lang/reflect/Modifier.h>
38 #include <java/util/Collection.h>
39 #include <java/util/HashMap.h>
40 #include <java/net/URL.h>
42 static void check_enabled_events (void);
43 static void check_enabled_event (jvmtiEvent);
49 bool ThreadStart = false;
50 bool ThreadEnd = false;
51 bool ClassFileLoadHook = false;
52 bool ClassLoad = false;
53 bool ClassPrepare = false;
55 bool Exception = false;
56 bool ExceptionCatch = false;
57 bool SingleStep = false;
58 bool FramePop = false;
59 bool Breakpoint = false;
60 bool FieldAccess = false;
61 bool FieldModification = false;
62 bool MethodEntry = false;
63 bool MethodExit = false;
64 bool NativeMethodBind = false;
65 bool CompiledMethodLoad = false;
66 bool CompiledMethodUnload = false;
67 bool DynamicCodeGenerated = false;
68 bool DataDumpRequest = false;
69 bool reserved72 = false;
70 bool MonitorWait = false;
71 bool MonitorWaited = false;
72 bool MonitorContendedEnter = false;
73 bool MonitorContendedEntered = false;
74 bool reserved77 = false;
75 bool reserved78 = false;
76 bool reserved79 = false;
77 bool reserved80 = false;
78 bool GarbageCollectionStart = false;
79 bool GarbageCollectionFinish = false;
80 bool ObjectFree = false;
81 bool VMObjectAlloc = false;
84 extern struct JNINativeInterface _Jv_JNIFunctions;
86 struct _Jv_rawMonitorID
89 _Jv_ConditionVariable_t condition;
92 /* A simple linked list of all JVMTI environments. Since
93 events must be delivered to environments in the order
94 in which the environments were created, new environments
95 are added to the end of the list. */
99 struct jvmti_env_list *next;
101 static struct jvmti_env_list *_jvmtiEnvironments = NULL;
102 static java::lang::Object *_envListLock = NULL;
103 #define FOREACH_ENVIRONMENT(Ele) \
104 for (Ele = _jvmtiEnvironments; Ele != NULL; Ele = Ele->next)
106 // Some commonly-used checks
108 #define THREAD_DEFAULT_TO_CURRENT(Ajthread) \
111 if (Ajthread == NULL) \
112 Ajthread = java::lang::Thread::currentThread (); \
116 #define THREAD_CHECK_VALID(Athread) \
119 if (!java::lang::Thread::class$.isAssignableFrom (&(Athread->class$))) \
120 return JVMTI_ERROR_INVALID_THREAD; \
124 #define THREAD_CHECK_IS_ALIVE(Athread) \
127 if (!Athread->isAlive ()) \
128 return JVMTI_ERROR_THREAD_NOT_ALIVE; \
132 // FIXME: if current phase is not set in Phases,
133 // return JVMTI_ERROR_WRONG_PHASE
134 #define REQUIRE_PHASE(Env, Phases)
136 #define NULL_CHECK(Ptr) \
140 return JVMTI_ERROR_NULL_POINTER; \
144 #define ILLEGAL_ARGUMENT(Cond) \
148 return JVMTI_ERROR_ILLEGAL_ARGUMENT; \
152 static jvmtiError JNICALL
153 _Jv_JVMTI_SuspendThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
155 using namespace java::lang;
157 THREAD_DEFAULT_TO_CURRENT (thread);
159 Thread *t = reinterpret_cast<Thread *> (thread);
160 THREAD_CHECK_VALID (t);
161 THREAD_CHECK_IS_ALIVE (t);
163 _Jv_Thread_t *data = _Jv_ThreadGetData (t);
164 _Jv_SuspendThread (data);
165 return JVMTI_ERROR_NONE;
168 static jvmtiError JNICALL
169 _Jv_JVMTI_ResumeThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
171 using namespace java::lang;
173 THREAD_DEFAULT_TO_CURRENT (thread);
175 Thread *t = reinterpret_cast<Thread *> (thread);
176 THREAD_CHECK_VALID (t);
177 THREAD_CHECK_IS_ALIVE (t);
179 _Jv_Thread_t *data = _Jv_ThreadGetData (t);
180 _Jv_ResumeThread (data);
181 return JVMTI_ERROR_NONE;
184 static jvmtiError JNICALL
185 _Jv_JVMTI_InterruptThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
187 using namespace java::lang;
189 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
190 // FIXME: capability handling? 'can_signal_thread'
192 return JVMTI_ERROR_INVALID_THREAD;
194 Thread *real_thread = reinterpret_cast<Thread *> (thread);
195 THREAD_CHECK_VALID (real_thread);
196 THREAD_CHECK_IS_ALIVE (real_thread);
197 real_thread->interrupt();
198 return JVMTI_ERROR_NONE;
201 static jvmtiError JNICALL
202 _Jv_JVMTI_GetAllThreads(MAYBE_UNUSED jvmtiEnv *env, jint *thread_cnt,
205 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
206 NULL_CHECK (thread_cnt);
207 NULL_CHECK (threads);
209 using namespace java::lang;
211 ThreadGroup *root_grp = ThreadGroup::root;
212 jint estimate = root_grp->activeCount ();
214 JArray<Thread *> *thr_arr;
216 // Allocate some extra space since threads can be created between calls
219 thr_arr = reinterpret_cast<JArray<Thread *> *> (JvNewObjectArray
221 &Thread::class$, NULL));
223 catch (java::lang::OutOfMemoryError *err)
225 return JVMTI_ERROR_OUT_OF_MEMORY;
228 *thread_cnt = root_grp->enumerate (thr_arr);
230 jvmtiError jerr = env->Allocate ((jlong) ((*thread_cnt) * sizeof (jthread)),
231 (unsigned char **) threads);
233 if (jerr != JVMTI_ERROR_NONE)
236 // Transfer the threads to the result array
237 jthread *tmp_arr = reinterpret_cast<jthread *> (elements (thr_arr));
239 memcpy ((*threads), tmp_arr, (*thread_cnt));
241 return JVMTI_ERROR_NONE;
244 static jvmtiError JNICALL
245 _Jv_JVMTI_CreateRawMonitor (MAYBE_UNUSED jvmtiEnv *env, const char *name,
246 jrawMonitorID *result)
248 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
251 *result = (jrawMonitorID) _Jv_MallocUnchecked (sizeof (_Jv_rawMonitorID));
253 return JVMTI_ERROR_OUT_OF_MEMORY;
254 _Jv_MutexInit (&(*result)->mutex);
255 _Jv_CondInit (&(*result)->condition);
256 return JVMTI_ERROR_NONE;
259 static jvmtiError JNICALL
260 _Jv_JVMTI_DestroyRawMonitor (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
262 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
263 // Note we have no better way of knowing whether this object is
264 // really a raw monitor.
266 return JVMTI_ERROR_INVALID_MONITOR;
267 // FIXME: perform checks on monitor, release it if this thread owns
269 #ifdef _Jv_HaveMutexDestroy
270 _Jv_MutexDestroy (&monitor->mutex);
273 return JVMTI_ERROR_NONE;
276 static jvmtiError JNICALL
277 _Jv_JVMTI_RawMonitorEnter (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
280 return JVMTI_ERROR_INVALID_MONITOR;
281 _Jv_MutexLock (&monitor->mutex);
282 return JVMTI_ERROR_NONE;
285 static jvmtiError JNICALL
286 _Jv_JVMTI_RawMonitorExit (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
289 return JVMTI_ERROR_INVALID_MONITOR;
290 if (_Jv_MutexUnlock (&monitor->mutex))
291 return JVMTI_ERROR_NOT_MONITOR_OWNER;
292 return JVMTI_ERROR_NONE;
295 static jvmtiError JNICALL
296 _Jv_JVMTI_RawMonitorWait (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor,
300 return JVMTI_ERROR_INVALID_MONITOR;
301 int r = _Jv_CondWait (&monitor->condition, &monitor->mutex, millis, 0);
302 if (r == _JV_NOT_OWNER)
303 return JVMTI_ERROR_NOT_MONITOR_OWNER;
304 if (r == _JV_INTERRUPTED)
305 return JVMTI_ERROR_INTERRUPT;
306 return JVMTI_ERROR_NONE;
309 static jvmtiError JNICALL
310 _Jv_JVMTI_RawMonitorNotify (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
313 return JVMTI_ERROR_INVALID_MONITOR;
314 if (_Jv_CondNotify (&monitor->condition, &monitor->mutex) == _JV_NOT_OWNER)
315 return JVMTI_ERROR_NOT_MONITOR_OWNER;
316 return JVMTI_ERROR_NONE;
319 static jvmtiError JNICALL
320 _Jv_JVMTI_RawMonitorNotifyAll (MAYBE_UNUSED jvmtiEnv *env,
321 jrawMonitorID monitor)
324 return JVMTI_ERROR_INVALID_MONITOR;
325 if (_Jv_CondNotifyAll (&monitor->condition, &monitor->mutex)
327 return JVMTI_ERROR_NOT_MONITOR_OWNER;
328 return JVMTI_ERROR_NONE;
331 static jvmtiError JNICALL
332 _Jv_JVMTI_SetBreakpoint (jvmtiEnv *env, jmethodID method, jlocation location)
334 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
336 using namespace gnu::gcj::jvmti;
338 = BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
343 jvmtiError err = env->GetMethodDeclaringClass (method, &klass);
344 if (err != JVMTI_ERROR_NONE)
347 if (!_Jv_IsInterpretedClass (klass))
348 return JVMTI_ERROR_INVALID_CLASS;
350 _Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
352 return JVMTI_ERROR_INVALID_METHODID;
355 err = env->GetMethodModifiers (method, &flags);
356 if (err != JVMTI_ERROR_NONE)
359 if (flags & java::lang::reflect::Modifier::NATIVE)
360 return JVMTI_ERROR_NATIVE_METHOD;
362 _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
363 if (imeth->get_insn (location) == NULL)
364 return JVMTI_ERROR_INVALID_LOCATION;
366 // Now the breakpoint can be safely installed
367 bp = BreakpointManager::newBreakpoint (reinterpret_cast<jlong> (method),
372 // Duplicate breakpoints are not permitted by JVMTI
373 return JVMTI_ERROR_DUPLICATE;
376 return JVMTI_ERROR_NONE;
379 static jvmtiError JNICALL
380 _Jv_JVMTI_ClearBreakpoint (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
383 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
385 using namespace gnu::gcj::jvmti;
388 = BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
391 return JVMTI_ERROR_NOT_FOUND;
393 BreakpointManager::deleteBreakpoint (reinterpret_cast<jlong> (method), location);
394 return JVMTI_ERROR_NONE;
397 static jvmtiError JNICALL
398 _Jv_JVMTI_Allocate (MAYBE_UNUSED jvmtiEnv *env, jlong size,
399 unsigned char **result)
401 ILLEGAL_ARGUMENT (size < 0);
407 *result = (unsigned char *) _Jv_MallocUnchecked (size);
409 return JVMTI_ERROR_OUT_OF_MEMORY;
411 return JVMTI_ERROR_NONE;
414 static jvmtiError JNICALL
415 _Jv_JVMTI_Deallocate (MAYBE_UNUSED jvmtiEnv *env, unsigned char *mem)
419 return JVMTI_ERROR_NONE;
422 static jvmtiError JNICALL
423 _Jv_JVMTI_GetClassStatus (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
426 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
427 NULL_CHECK (status_ptr);
429 return JVMTI_ERROR_INVALID_CLASS;
431 if (klass->isArray ())
432 *status_ptr = JVMTI_CLASS_STATUS_ARRAY;
433 else if (klass->isPrimitive ())
434 *status_ptr = JVMTI_CLASS_STATUS_PRIMITIVE;
437 jbyte state = _Jv_GetClassState (klass);
439 if (state >= JV_STATE_LINKED)
440 (*status_ptr) |= JVMTI_CLASS_STATUS_VERIFIED;
441 if (state >= JV_STATE_PREPARED)
442 (*status_ptr) |= JVMTI_CLASS_STATUS_PREPARED;
443 if (state == JV_STATE_ERROR || state == JV_STATE_PHANTOM)
444 (*status_ptr) |= JVMTI_CLASS_STATUS_ERROR;
445 else if (state == JV_STATE_DONE)
446 (*status_ptr) |= JVMTI_CLASS_STATUS_INITIALIZED;
449 return JVMTI_ERROR_NONE;
452 static jvmtiError JNICALL
453 _Jv_JVMTI_GetClassModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
456 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
457 // Don't bother checking KLASS' type.
459 return JVMTI_ERROR_INVALID_CLASS;
461 *mods = klass->getModifiers();
462 return JVMTI_ERROR_NONE;
465 static jvmtiError JNICALL
466 _Jv_JVMTI_GetClassMethods (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
467 jint *count_ptr, jmethodID **methods_ptr)
469 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
470 // FIXME: capability can_maintain_original_method_order
471 // Don't bother checking KLASS' type.
473 return JVMTI_ERROR_INVALID_CLASS;
474 NULL_CHECK (count_ptr);
475 NULL_CHECK (methods_ptr);
476 *count_ptr = JvNumMethods(klass);
479 = (jmethodID *) _Jv_MallocUnchecked (*count_ptr * sizeof (jmethodID));
480 if (*methods_ptr == NULL)
481 return JVMTI_ERROR_OUT_OF_MEMORY;
483 jmethodID start = JvGetFirstMethod (klass);
484 for (jint i = 0; i < *count_ptr; ++i)
486 (*methods_ptr)[i] = start + i;
488 return JVMTI_ERROR_NONE;
491 static jvmtiError JNICALL
492 _Jv_JVMTI_IsInterface (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
495 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
497 return JVMTI_ERROR_INVALID_CLASS;
499 *result = klass->isInterface();
500 return JVMTI_ERROR_NONE;
503 static jvmtiError JNICALL
504 _Jv_JVMTI_IsArrayClass (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
507 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
509 return JVMTI_ERROR_INVALID_CLASS;
511 *result = klass->isArray();
512 return JVMTI_ERROR_NONE;
515 static jvmtiError JNICALL
516 _Jv_JVMTI_GetClassLoader (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
519 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
521 return JVMTI_ERROR_INVALID_CLASS;
523 *result = klass->getClassLoaderInternal();
524 return JVMTI_ERROR_NONE;
527 static jvmtiError JNICALL
528 _Jv_JVMTI_GetObjectHashCode (MAYBE_UNUSED jvmtiEnv *env, jobject obj,
531 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
533 return JVMTI_ERROR_INVALID_OBJECT;
535 *result = _Jv_HashCode (obj);
536 return JVMTI_ERROR_NONE;
539 static jvmtiError JNICALL
540 _Jv_JVMTI_GetFieldModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
541 jfieldID field, jint *result)
543 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
545 return JVMTI_ERROR_INVALID_CLASS;
547 return JVMTI_ERROR_INVALID_FIELDID;
549 *result = field->getModifiers();
550 return JVMTI_ERROR_NONE;
553 static jvmtiError JNICALL
554 _Jv_JVMTI_IsFieldSynthetic (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
555 jfieldID field, jboolean *result)
557 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
559 return JVMTI_ERROR_INVALID_CLASS;
561 return JVMTI_ERROR_INVALID_FIELDID;
564 // FIXME: capability can_get_synthetic_attribute
565 *result = ((field->getModifiers() & java::lang::reflect::Modifier::SYNTHETIC)
567 return JVMTI_ERROR_NONE;
570 static jvmtiError JNICALL
571 _Jv_JVMTI_GetMethodModifiers (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
574 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
576 return JVMTI_ERROR_INVALID_METHODID;
579 // FIXME: mask off some internal bits...
580 *result = method->accflags;
581 return JVMTI_ERROR_NONE;
584 static jvmtiError JNICALL
585 _Jv_JVMTI_GetLineNumberTable (jvmtiEnv *env, jmethodID method,
586 jint *entry_count_ptr,
587 jvmtiLineNumberEntry **table_ptr)
589 NULL_CHECK (entry_count_ptr);
590 NULL_CHECK (table_ptr);
593 jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
594 if (jerr != JVMTI_ERROR_NONE)
597 _Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
599 return JVMTI_ERROR_INVALID_METHODID;
601 if (java::lang::reflect::Modifier::isNative (method->accflags)
602 || !_Jv_IsInterpretedClass (klass))
603 return JVMTI_ERROR_NATIVE_METHOD;
605 _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
607 jintArray lines = NULL;
608 jlongArray indices = NULL;
609 imeth->get_line_table (start, end, lines, indices);
611 return JVMTI_ERROR_ABSENT_INFORMATION;
613 jvmtiLineNumberEntry *table;
614 jsize len = lines->length * sizeof (jvmtiLineNumberEntry);
615 table = (jvmtiLineNumberEntry *) _Jv_MallocUnchecked (len);
617 return JVMTI_ERROR_OUT_OF_MEMORY;
619 jint *line = elements (lines);
620 jlong *index = elements (indices);
621 for (int i = 0; i < lines->length; ++i)
623 table[i].start_location = index[i];
624 table[i].line_number = line[i];
628 *entry_count_ptr = lines->length;
629 return JVMTI_ERROR_NONE;
632 static jvmtiError JNICALL
633 _Jv_JVMTI_IsMethodNative (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
636 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
638 return JVMTI_ERROR_INVALID_METHODID;
641 *result = ((method->accflags & java::lang::reflect::Modifier::NATIVE) != 0);
642 return JVMTI_ERROR_NONE;
645 static jvmtiError JNICALL
646 _Jv_JVMTI_IsMethodSynthetic (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
649 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
651 return JVMTI_ERROR_INVALID_METHODID;
654 // FIXME capability can_get_synthetic_attribute
656 *result = ((method->accflags & java::lang::reflect::Modifier::SYNTHETIC)
658 return JVMTI_ERROR_NONE;
661 static jvmtiError JNICALL
662 _Jv_JVMTI_GetMethodDeclaringClass (MAYBE_UNUSED jvmtiEnv *env,
664 jclass *declaring_class_ptr)
666 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
667 NULL_CHECK (declaring_class_ptr);
669 jclass klass = _Jv_GetMethodDeclaringClass (method);
672 *declaring_class_ptr = klass;
673 return JVMTI_ERROR_NONE;
676 return JVMTI_ERROR_INVALID_METHODID;
679 static jvmtiError JNICALL
680 _Jv_JVMTI_GetClassLoaderClasses (MAYBE_UNUSED jvmtiEnv *env,
685 using namespace java::lang;
686 using namespace java::util;
688 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
689 NULL_CHECK (count_ptr);
690 NULL_CHECK (result_ptr);
692 ClassLoader *loader = (ClassLoader *) init_loader;
694 loader = VMClassLoader::bootLoader;
696 Collection *values = loader->loadedClasses->values();
697 jobjectArray array = values->toArray();
698 *count_ptr = array->length;
699 jobject *elts = elements (array);
701 = (jclass *) _Jv_MallocUnchecked (*count_ptr * sizeof (jclass));
703 return JVMTI_ERROR_OUT_OF_MEMORY;
705 // FIXME: JNI references...
706 memcpy (result, elts, *count_ptr * sizeof (jclass));
708 *result_ptr = result;
710 return JVMTI_ERROR_NONE;
713 static jvmtiError JNICALL
714 _Jv_JVMTI_ForceGarbageCollection (MAYBE_UNUSED jvmtiEnv *env)
716 REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
718 return JVMTI_ERROR_NONE;
721 static jvmtiError JNICALL
722 _Jv_JVMTI_SetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
723 const jniNativeInterface *function_table)
725 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
726 NULL_CHECK (function_table);
727 memcpy (&_Jv_JNIFunctions, function_table, sizeof (jniNativeInterface));
728 return JVMTI_ERROR_NONE;
731 static jvmtiError JNICALL
732 _Jv_JVMTI_GetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
733 jniNativeInterface **function_table)
735 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
736 NULL_CHECK (function_table);
738 = (jniNativeInterface *) _Jv_MallocUnchecked (sizeof (jniNativeInterface));
739 if (*function_table == NULL)
740 return JVMTI_ERROR_OUT_OF_MEMORY;
741 memcpy (*function_table, &_Jv_JNIFunctions, sizeof (jniNativeInterface));
742 return JVMTI_ERROR_NONE;
745 static jvmtiError JNICALL
746 _Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env)
750 if (_jvmtiEnvironments == NULL)
751 return JVMTI_ERROR_INVALID_ENVIRONMENT;
754 JvSynchronize dummy (_envListLock);
755 if (_jvmtiEnvironments->env == env)
757 struct jvmti_env_list *next = _jvmtiEnvironments->next;
758 _Jv_Free (_jvmtiEnvironments);
759 _jvmtiEnvironments = next;
763 struct jvmti_env_list *e = _jvmtiEnvironments;
764 while (e->next != NULL && e->next->env != env)
767 return JVMTI_ERROR_INVALID_ENVIRONMENT;
769 struct jvmti_env_list *next = e->next->next;
777 check_enabled_events ();
779 return JVMTI_ERROR_NONE;
782 static jvmtiError JNICALL
783 _Jv_JVMTI_GetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
786 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
787 NULL_CHECK (property);
790 jstring name = JvNewStringUTF(property);
791 jstring result_str = gnu::classpath::SystemProperties::getProperty(name);
793 if (result_str == NULL)
794 return JVMTI_ERROR_NOT_AVAILABLE;
796 int len = JvGetStringUTFLength (result_str);
797 *result = (char *) _Jv_MallocUnchecked (len + 1);
799 return JVMTI_ERROR_OUT_OF_MEMORY;
800 JvGetStringUTFRegion (result_str, 0, result_str->length(), *result);
801 (*result)[len] = '\0';
803 return JVMTI_ERROR_NONE;
806 static jvmtiError JNICALL
807 _Jv_JVMTI_SetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
810 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
812 NULL_CHECK (property);
815 // FIXME: When would a property not be writeable?
816 return JVMTI_ERROR_NONE;
819 jstring prop_str = JvNewStringUTF(property);
820 jstring value_str = JvNewStringUTF(value);
821 gnu::classpath::SystemProperties::setProperty(prop_str, value_str);
822 return JVMTI_ERROR_NONE;
825 static jvmtiError JNICALL
826 _Jv_JVMTI_GetTime (MAYBE_UNUSED jvmtiEnv *env, jlong *nanos_ptr)
828 NULL_CHECK (nanos_ptr);
829 *nanos_ptr = _Jv_platform_nanotime();
830 return JVMTI_ERROR_NONE;
833 static jvmtiError JNICALL
834 _Jv_JVMTI_GetAvailableProcessors (MAYBE_UNUSED jvmtiEnv *env,
835 jint *nprocessors_ptr)
837 NULL_CHECK (nprocessors_ptr);
838 #ifdef _SC_NPROCESSORS_ONLN
839 *nprocessors_ptr = sysconf(_SC_NPROCESSORS_ONLN);
841 *nprocessors_ptr = 1;
843 return JVMTI_ERROR_NONE;
846 static jvmtiError JNICALL
847 _Jv_JVMTI_AddToBootstrapClassLoaderSearch (MAYBE_UNUSED jvmtiEnv *env,
850 using namespace java::lang;
851 using namespace java::net;
852 using namespace gnu::gcj::runtime;
854 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
855 NULL_CHECK (segment);
857 jstring str_segment = JvNewStringUTF(segment);
861 url = new URL(JvNewStringUTF("file"), NULL, str_segment);
863 catch (jthrowable ignore)
865 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
868 BootClassLoader *loader = VMClassLoader::bootLoader;
869 // Don't call this too early.
870 // assert (loader != NULL);
872 return JVMTI_ERROR_NONE;
875 static jvmtiError JNICALL
876 _Jv_JVMTI_SetVerboseFlag (MAYBE_UNUSED jvmtiEnv *env, jvmtiVerboseFlag flag,
881 case JVMTI_VERBOSE_OTHER:
882 case JVMTI_VERBOSE_GC:
883 case JVMTI_VERBOSE_JNI:
886 case JVMTI_VERBOSE_CLASS:
887 gcj::verbose_class_flag = value;
890 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
892 return JVMTI_ERROR_NONE;
895 static jvmtiError JNICALL
896 _Jv_JVMTI_GetObjectSize (MAYBE_UNUSED jvmtiEnv *env, jobject object,
899 REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
901 return JVMTI_ERROR_INVALID_OBJECT;
904 jclass klass = object->getClass();
905 if (klass->isArray())
907 jclass comp = klass->getComponentType();
909 = (jint) (_Jv_uintptr_t) _Jv_GetArrayElementFromElementType(NULL,
910 klass->getComponentType());
911 // FIXME: correct for primitive types?
912 jint compSize = comp->size();
913 __JArray *array = (__JArray *) object;
914 *result = base + array->length * compSize;
918 // Note that if OBJECT is a String then it may (if
919 // str->data==str) take more space. Do we care?
920 *result = klass->size();
922 return JVMTI_ERROR_NONE;
925 /* An event is enabled only if it has both an event handler
926 and it is enabled in the environment. */
928 check_enabled_event (jvmtiEvent type)
933 #define GET_OFFSET(Event) \
936 enabled = &JVMTI::Event; \
937 offset = offsetof (jvmtiEventCallbacks, Event); \
943 case JVMTI_EVENT_VM_INIT:
947 case JVMTI_EVENT_VM_DEATH:
948 GET_OFFSET (VMDeath);
951 case JVMTI_EVENT_THREAD_START:
952 GET_OFFSET (ThreadStart);
955 case JVMTI_EVENT_THREAD_END:
956 GET_OFFSET (ThreadEnd);
959 case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
960 GET_OFFSET (ClassFileLoadHook);
963 case JVMTI_EVENT_CLASS_LOAD:
964 GET_OFFSET (ClassLoad);
967 case JVMTI_EVENT_CLASS_PREPARE:
968 GET_OFFSET (ClassPrepare);
971 case JVMTI_EVENT_VM_START:
972 GET_OFFSET (VMStart);
975 case JVMTI_EVENT_EXCEPTION:
976 GET_OFFSET (Exception);
979 case JVMTI_EVENT_EXCEPTION_CATCH:
980 GET_OFFSET (ExceptionCatch);
983 case JVMTI_EVENT_SINGLE_STEP:
984 GET_OFFSET (SingleStep);
987 case JVMTI_EVENT_FRAME_POP:
988 GET_OFFSET (FramePop);
991 case JVMTI_EVENT_BREAKPOINT:
992 GET_OFFSET (Breakpoint);
995 case JVMTI_EVENT_FIELD_ACCESS:
996 GET_OFFSET (FieldAccess);
999 case JVMTI_EVENT_FIELD_MODIFICATION:
1000 GET_OFFSET (FieldModification);
1003 case JVMTI_EVENT_METHOD_ENTRY:
1004 GET_OFFSET (MethodEntry);
1007 case JVMTI_EVENT_METHOD_EXIT:
1008 GET_OFFSET (MethodExit);
1011 case JVMTI_EVENT_NATIVE_METHOD_BIND:
1012 GET_OFFSET (NativeMethodBind);
1015 case JVMTI_EVENT_COMPILED_METHOD_LOAD:
1016 GET_OFFSET (CompiledMethodLoad);
1019 case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
1020 GET_OFFSET (CompiledMethodUnload);
1023 case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
1024 GET_OFFSET (DynamicCodeGenerated);
1027 case JVMTI_EVENT_DATA_DUMP_REQUEST:
1028 GET_OFFSET (DataDumpRequest);
1031 case JVMTI_EVENT_MONITOR_WAIT:
1032 GET_OFFSET (MonitorWait);
1035 case JVMTI_EVENT_MONITOR_WAITED:
1036 GET_OFFSET (MonitorWaited);
1039 case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
1040 GET_OFFSET (MonitorContendedEnter);
1043 case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
1044 GET_OFFSET (MonitorContendedEntered);
1047 case JVMTI_EVENT_GARBAGE_COLLECTION_START:
1048 GET_OFFSET (GarbageCollectionStart);
1051 case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
1052 GET_OFFSET (GarbageCollectionFinish);
1055 case JVMTI_EVENT_OBJECT_FREE:
1056 GET_OFFSET (ObjectFree);
1059 case JVMTI_EVENT_VM_OBJECT_ALLOC:
1060 GET_OFFSET (VMObjectAlloc);
1065 "libgcj: check_enabled_event for unknown JVMTI event (%d)\n",
1071 int index = EVENT_INDEX (type); // safe since caller checks this
1073 JvSynchronize dummy (_envListLock);
1074 struct jvmti_env_list *e;
1075 FOREACH_ENVIRONMENT (e)
1078 = reinterpret_cast<char *> (&e->env->callbacks) + offset;
1079 void **callback = reinterpret_cast<void **> (addr);
1080 if (e->env->enabled[index] && *callback != NULL)
1091 check_enabled_events ()
1093 check_enabled_event (JVMTI_EVENT_VM_INIT);
1094 check_enabled_event (JVMTI_EVENT_VM_DEATH);
1095 check_enabled_event (JVMTI_EVENT_THREAD_START);
1096 check_enabled_event (JVMTI_EVENT_THREAD_END);
1097 check_enabled_event (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK);
1098 check_enabled_event (JVMTI_EVENT_CLASS_LOAD);
1099 check_enabled_event (JVMTI_EVENT_CLASS_PREPARE);
1100 check_enabled_event (JVMTI_EVENT_VM_START);
1101 check_enabled_event (JVMTI_EVENT_EXCEPTION);
1102 check_enabled_event (JVMTI_EVENT_EXCEPTION_CATCH);
1103 check_enabled_event (JVMTI_EVENT_SINGLE_STEP);
1104 check_enabled_event (JVMTI_EVENT_FRAME_POP);
1105 check_enabled_event (JVMTI_EVENT_BREAKPOINT);
1106 check_enabled_event (JVMTI_EVENT_FIELD_ACCESS);
1107 check_enabled_event (JVMTI_EVENT_FIELD_MODIFICATION);
1108 check_enabled_event (JVMTI_EVENT_METHOD_ENTRY);
1109 check_enabled_event (JVMTI_EVENT_METHOD_EXIT);
1110 check_enabled_event (JVMTI_EVENT_NATIVE_METHOD_BIND);
1111 check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_LOAD);
1112 check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_UNLOAD);
1113 check_enabled_event (JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
1114 check_enabled_event (JVMTI_EVENT_DATA_DUMP_REQUEST);
1115 check_enabled_event (JVMTI_EVENT_MONITOR_WAIT);
1116 check_enabled_event (JVMTI_EVENT_MONITOR_WAITED);
1117 check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTER);
1118 check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED);
1119 check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_START);
1120 check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH);
1121 check_enabled_event (JVMTI_EVENT_OBJECT_FREE);
1122 check_enabled_event (JVMTI_EVENT_VM_OBJECT_ALLOC);
1125 static jvmtiError JNICALL
1126 _Jv_JVMTI_SetEventNotificationMode (jvmtiEnv *env, jvmtiEventMode mode,
1127 jvmtiEvent type, jthread event_thread, ...)
1129 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
1131 if (event_thread != NULL)
1133 using namespace java::lang;
1134 Thread *t = reinterpret_cast<Thread *> (event_thread);
1135 THREAD_CHECK_VALID (t);
1136 THREAD_CHECK_IS_ALIVE (t);
1150 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1155 case JVMTI_EVENT_VM_INIT:
1156 case JVMTI_EVENT_VM_DEATH:
1157 case JVMTI_EVENT_THREAD_START:
1158 case JVMTI_EVENT_VM_START:
1159 case JVMTI_EVENT_COMPILED_METHOD_LOAD:
1160 case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
1161 case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
1162 case JVMTI_EVENT_DATA_DUMP_REQUEST:
1163 ILLEGAL_ARGUMENT (event_thread != NULL);
1166 case JVMTI_EVENT_THREAD_END:
1167 case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
1168 case JVMTI_EVENT_CLASS_LOAD:
1169 case JVMTI_EVENT_CLASS_PREPARE:
1170 case JVMTI_EVENT_EXCEPTION:
1171 case JVMTI_EVENT_EXCEPTION_CATCH:
1172 case JVMTI_EVENT_SINGLE_STEP:
1173 case JVMTI_EVENT_FRAME_POP:
1174 case JVMTI_EVENT_BREAKPOINT:
1175 case JVMTI_EVENT_FIELD_ACCESS:
1176 case JVMTI_EVENT_FIELD_MODIFICATION:
1177 case JVMTI_EVENT_METHOD_ENTRY:
1178 case JVMTI_EVENT_METHOD_EXIT:
1179 case JVMTI_EVENT_NATIVE_METHOD_BIND:
1180 case JVMTI_EVENT_MONITOR_WAIT:
1181 case JVMTI_EVENT_MONITOR_WAITED:
1182 case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
1183 case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
1184 case JVMTI_EVENT_GARBAGE_COLLECTION_START:
1185 case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
1186 case JVMTI_EVENT_OBJECT_FREE:
1187 case JVMTI_EVENT_VM_OBJECT_ALLOC:
1191 return JVMTI_ERROR_INVALID_EVENT_TYPE;
1194 env->thread[EVENT_INDEX(type)] = event_thread;
1195 env->enabled[EVENT_INDEX(type)] = enabled;
1196 check_enabled_event (type);
1197 return JVMTI_ERROR_NONE;
1200 static jvmtiError JNICALL
1201 _Jv_JVMTI_SetEventCallbacks (jvmtiEnv *env,
1202 const jvmtiEventCallbacks *callbacks,
1203 jint size_of_callbacks)
1205 REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
1206 ILLEGAL_ARGUMENT (size_of_callbacks < 0);
1208 // Copy the list of callbacks into the environment
1209 memcpy (&env->callbacks, callbacks, sizeof (jvmtiEventCallbacks));
1211 /* Check which events are now enabeld (JVMTI makes no requirements
1212 about the order in which SetEventCallbacks and SetEventNotifications
1213 are called. So we must check all events here. */
1214 check_enabled_events ();
1216 return JVMTI_ERROR_NONE;
1219 static jvmtiError JNICALL
1220 _Jv_JVMTI_GetErrorName (MAYBE_UNUSED jvmtiEnv *env, jvmtiError error,
1223 NULL_CHECK (name_ptr);
1228 case JVMTI_ERROR_NONE:
1232 case JVMTI_ERROR_NULL_POINTER:
1233 name = "null pointer";
1236 case JVMTI_ERROR_OUT_OF_MEMORY:
1237 name = "out of memory";
1240 case JVMTI_ERROR_ACCESS_DENIED:
1241 name = "access denied";
1244 case JVMTI_ERROR_WRONG_PHASE:
1245 name = "wrong phase";
1248 case JVMTI_ERROR_INTERNAL:
1249 name = "internal error";
1252 case JVMTI_ERROR_UNATTACHED_THREAD:
1253 name = "unattached thread";
1256 case JVMTI_ERROR_INVALID_ENVIRONMENT:
1257 name = "invalid environment";
1260 case JVMTI_ERROR_INVALID_PRIORITY:
1261 name = "invalid priority";
1264 case JVMTI_ERROR_THREAD_NOT_SUSPENDED:
1265 name = "thread not suspended";
1268 case JVMTI_ERROR_THREAD_SUSPENDED:
1269 name = "thread suspended";
1272 case JVMTI_ERROR_THREAD_NOT_ALIVE:
1273 name = "thread not alive";
1276 case JVMTI_ERROR_CLASS_NOT_PREPARED:
1277 name = "class not prepared";
1280 case JVMTI_ERROR_NO_MORE_FRAMES:
1281 name = "no more frames";
1284 case JVMTI_ERROR_OPAQUE_FRAME:
1285 name = "opaque frame";
1288 case JVMTI_ERROR_DUPLICATE:
1292 case JVMTI_ERROR_NOT_FOUND:
1296 case JVMTI_ERROR_NOT_MONITOR_OWNER:
1297 name = "not monitor owner";
1300 case JVMTI_ERROR_INTERRUPT:
1301 name = "interrupted";
1304 case JVMTI_ERROR_UNMODIFIABLE_CLASS:
1305 name = "unmodifiable class";
1308 case JVMTI_ERROR_NOT_AVAILABLE:
1309 name = "not available";
1312 case JVMTI_ERROR_ABSENT_INFORMATION:
1313 name = "absent information";
1316 case JVMTI_ERROR_INVALID_EVENT_TYPE:
1317 name = "invalid event type";
1320 case JVMTI_ERROR_NATIVE_METHOD:
1321 name = "native method";
1324 case JVMTI_ERROR_INVALID_THREAD:
1325 name = "invalid thread";
1328 case JVMTI_ERROR_INVALID_THREAD_GROUP:
1329 name = "invalid thread group";
1332 case JVMTI_ERROR_INVALID_OBJECT:
1333 name = "invalid object";
1336 case JVMTI_ERROR_INVALID_CLASS:
1337 name = "invalid class";
1340 case JVMTI_ERROR_INVALID_METHODID:
1341 name = "invalid method ID";
1344 case JVMTI_ERROR_INVALID_LOCATION:
1345 name = "invalid location";
1348 case JVMTI_ERROR_INVALID_FIELDID:
1349 name = "invalid field ID";
1352 case JVMTI_ERROR_TYPE_MISMATCH:
1353 name = "type mismatch";
1356 case JVMTI_ERROR_INVALID_SLOT:
1357 name = "invalid slot";
1360 case JVMTI_ERROR_INVALID_MONITOR:
1361 name = "invalid monitor";
1364 case JVMTI_ERROR_INVALID_CLASS_FORMAT:
1365 name = "invalid class format";
1368 case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION:
1369 name = "circular class definition";
1372 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED:
1373 name = "unsupported redefinition: method added";
1376 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED:
1377 name = "unsupported redefinition: schema changed";
1380 case JVMTI_ERROR_INVALID_TYPESTATE:
1381 name = "invalid type state";
1384 case JVMTI_ERROR_FAILS_VERIFICATION:
1385 name = "fails verification";
1388 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED:
1389 name = "unsupported redefinition: hierarchy changed";
1392 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED:
1393 name = "unsupported redefinition: method deleted";
1396 case JVMTI_ERROR_UNSUPPORTED_VERSION:
1397 name = "unsupported version";
1400 case JVMTI_ERROR_NAMES_DONT_MATCH:
1401 name = "names do not match";
1404 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED:
1405 name = "unsupported redefinition: class modifiers changed";
1408 case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED:
1409 name = "unsupported redefinition: method modifiers changed";
1412 case JVMTI_ERROR_MUST_POSSESS_CAPABILITY:
1413 name = "must possess capability";
1416 case JVMTI_ERROR_ILLEGAL_ARGUMENT:
1417 name = "illegal argument";
1421 return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1424 *name_ptr = (char *) _Jv_MallocUnchecked (strlen (name) + 1);
1425 if (*name_ptr == NULL)
1426 return JVMTI_ERROR_OUT_OF_MEMORY;
1428 strcpy (*name_ptr, name);
1429 return JVMTI_ERROR_NONE;
1432 #define RESERVED NULL
1433 #define UNIMPLEMENTED NULL
1435 struct _Jv_jvmtiEnv _Jv_JVMTI_Interface =
1437 RESERVED, // reserved1
1438 _Jv_JVMTI_SetEventNotificationMode, // SetEventNotificationMode
1439 RESERVED, // reserved3
1440 _Jv_JVMTI_GetAllThreads, // GetAllThreads
1441 _Jv_JVMTI_SuspendThread, // SuspendThread
1442 _Jv_JVMTI_ResumeThread, // ResumeThread
1443 UNIMPLEMENTED, // StopThread
1444 _Jv_JVMTI_InterruptThread, // InterruptThread
1445 UNIMPLEMENTED, // GetThreadInfo
1446 UNIMPLEMENTED, // GetOwnedMonitorInfo
1447 UNIMPLEMENTED, // GetCurrentContendedMonitor
1448 UNIMPLEMENTED, // RunAgentThread
1449 UNIMPLEMENTED, // GetTopThreadGroups
1450 UNIMPLEMENTED, // GetThreadGroupInfo
1451 UNIMPLEMENTED, // GetThreadGroupChildren
1452 UNIMPLEMENTED, // GetFrameCount
1453 UNIMPLEMENTED, // GetThreadState
1454 RESERVED, // reserved18
1455 UNIMPLEMENTED, // GetFrameLocation
1456 UNIMPLEMENTED, // NotifyPopFrame
1457 UNIMPLEMENTED, // GetLocalObject
1458 UNIMPLEMENTED, // GetLocalInt
1459 UNIMPLEMENTED, // GetLocalLong
1460 UNIMPLEMENTED, // GetLocalFloat
1461 UNIMPLEMENTED, // GetLocalDouble
1462 UNIMPLEMENTED, // SetLocalObject
1463 UNIMPLEMENTED, // SetLocalInt
1464 UNIMPLEMENTED, // SetLocalLong
1465 UNIMPLEMENTED, // SetLocalFloat
1466 UNIMPLEMENTED, // SetLocalDouble
1467 _Jv_JVMTI_CreateRawMonitor, // CreateRawMonitor
1468 _Jv_JVMTI_DestroyRawMonitor, // DestroyRawMonitor
1469 _Jv_JVMTI_RawMonitorEnter, // RawMonitorEnter
1470 _Jv_JVMTI_RawMonitorExit, // RawMonitorExit
1471 _Jv_JVMTI_RawMonitorWait, // RawMonitorWait
1472 _Jv_JVMTI_RawMonitorNotify, // RawMonitorNotify
1473 _Jv_JVMTI_RawMonitorNotifyAll, // RawMonitorNotifyAll
1474 _Jv_JVMTI_SetBreakpoint, // SetBreakpoint
1475 _Jv_JVMTI_ClearBreakpoint, // ClearBreakpoint
1476 RESERVED, // reserved40
1477 UNIMPLEMENTED, // SetFieldAccessWatch
1478 UNIMPLEMENTED, // ClearFieldAccessWatch
1479 UNIMPLEMENTED, // SetFieldModificationWatch
1480 UNIMPLEMENTED, // ClearFieldModificationWatch
1481 RESERVED, // reserved45
1482 _Jv_JVMTI_Allocate, // Allocate
1483 _Jv_JVMTI_Deallocate, // Deallocate
1484 UNIMPLEMENTED, // GetClassSignature
1485 _Jv_JVMTI_GetClassStatus, // GetClassStatus
1486 UNIMPLEMENTED, // GetSourceFileName
1487 _Jv_JVMTI_GetClassModifiers, // GetClassModifiers
1488 _Jv_JVMTI_GetClassMethods, // GetClassMethods
1489 UNIMPLEMENTED, // GetClassFields
1490 UNIMPLEMENTED, // GetImplementedInterfaces
1491 _Jv_JVMTI_IsInterface, // IsInterface
1492 _Jv_JVMTI_IsArrayClass, // IsArrayClass
1493 _Jv_JVMTI_GetClassLoader, // GetClassLoader
1494 _Jv_JVMTI_GetObjectHashCode, // GetObjectHashCode
1495 UNIMPLEMENTED, // GetObjectMonitorUsage
1496 UNIMPLEMENTED, // GetFieldName
1497 UNIMPLEMENTED, // GetFieldDeclaringClass
1498 _Jv_JVMTI_GetFieldModifiers, // GetFieldModifiers
1499 _Jv_JVMTI_IsFieldSynthetic, // IsFieldSynthetic
1500 UNIMPLEMENTED, // GetMethodName
1501 _Jv_JVMTI_GetMethodDeclaringClass, // GetMethodDeclaringClass
1502 _Jv_JVMTI_GetMethodModifiers, // GetMethodModifers
1503 RESERVED, // reserved67
1504 UNIMPLEMENTED, // GetMaxLocals
1505 UNIMPLEMENTED, // GetArgumentsSize
1506 _Jv_JVMTI_GetLineNumberTable, // GetLineNumberTable
1507 UNIMPLEMENTED, // GetMethodLocation
1508 UNIMPLEMENTED, // GetLocalVariableTable
1509 RESERVED, // reserved73
1510 RESERVED, // reserved74
1511 UNIMPLEMENTED, // GetBytecodes
1512 _Jv_JVMTI_IsMethodNative, // IsMethodNative
1513 _Jv_JVMTI_IsMethodSynthetic, // IsMethodSynthetic
1514 UNIMPLEMENTED, // GetLoadedClasses
1515 _Jv_JVMTI_GetClassLoaderClasses, // GetClassLoaderClasses
1516 UNIMPLEMENTED, // PopFrame
1517 RESERVED, // reserved81
1518 RESERVED, // reserved82
1519 RESERVED, // reserved83
1520 RESERVED, // reserved84
1521 RESERVED, // reserved85
1522 RESERVED, // reserved86
1523 UNIMPLEMENTED, // RedefineClasses
1524 UNIMPLEMENTED, // GetVersionNumber
1525 UNIMPLEMENTED, // GetCapabilities
1526 UNIMPLEMENTED, // GetSourceDebugExtension
1527 UNIMPLEMENTED, // IsMethodObsolete
1528 UNIMPLEMENTED, // SuspendThreadList
1529 UNIMPLEMENTED, // ResumeThreadList
1530 RESERVED, // reserved94
1531 RESERVED, // reserved95
1532 RESERVED, // reserved96
1533 RESERVED, // reserved97
1534 RESERVED, // reserved98
1535 RESERVED, // reserved99
1536 UNIMPLEMENTED, // GetAllStackTraces
1537 UNIMPLEMENTED, // GetThreadListStackTraces
1538 UNIMPLEMENTED, // GetThreadLocalStorage
1539 UNIMPLEMENTED, // SetThreadLocalStorage
1540 UNIMPLEMENTED, // GetStackTrace
1541 RESERVED, // reserved105
1542 UNIMPLEMENTED, // GetTag
1543 UNIMPLEMENTED, // SetTag
1544 _Jv_JVMTI_ForceGarbageCollection, // ForceGarbageCollection
1545 UNIMPLEMENTED, // IterateOverObjectsReachable
1546 UNIMPLEMENTED, // IterateOverReachableObjects
1547 UNIMPLEMENTED, // IterateOverHeap
1548 UNIMPLEMENTED, // IterateOverInstanceOfClass
1549 RESERVED, // reserved113
1550 UNIMPLEMENTED, // GetObjectsWithTags
1551 RESERVED, // reserved115
1552 RESERVED, // reserved116
1553 RESERVED, // reserved117
1554 RESERVED, // reserved118
1555 RESERVED, // reserved119
1556 _Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable
1557 _Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable
1558 _Jv_JVMTI_SetEventCallbacks, // SetEventCallbacks
1559 UNIMPLEMENTED, // GenerateEvents
1560 UNIMPLEMENTED, // GetExtensionFunctions
1561 UNIMPLEMENTED, // GetExtensionEvents
1562 UNIMPLEMENTED, // SetExtensionEventCallback
1563 _Jv_JVMTI_DisposeEnvironment, // DisposeEnvironment
1564 _Jv_JVMTI_GetErrorName, // GetErrorName
1565 UNIMPLEMENTED, // GetJLocationFormat
1566 UNIMPLEMENTED, // GetSystemProperties
1567 _Jv_JVMTI_GetSystemProperty, // GetSystemProperty
1568 _Jv_JVMTI_SetSystemProperty, // SetSystemProperty
1569 UNIMPLEMENTED, // GetPhase
1570 UNIMPLEMENTED, // GetCurrentThreadCpuTimerInfo
1571 UNIMPLEMENTED, // GetCurrentThreadCpuTime
1572 UNIMPLEMENTED, // GetThreadCpuTimerInfo
1573 UNIMPLEMENTED, // GetThreadCpuTime
1574 UNIMPLEMENTED, // GetTimerInfo
1575 _Jv_JVMTI_GetTime, // GetTime
1576 UNIMPLEMENTED, // GetPotentialCapabilities
1577 RESERVED, // reserved141
1578 UNIMPLEMENTED, // AddCapabilities
1579 UNIMPLEMENTED, // RelinquishCapabilities
1580 _Jv_JVMTI_GetAvailableProcessors, // GetAvailableProcessors
1581 RESERVED, // reserved145
1582 RESERVED, // reserved146
1583 UNIMPLEMENTED, // GetEnvironmentLocalStorage
1584 UNIMPLEMENTED, // SetEnvironmentLocalStorage
1585 _Jv_JVMTI_AddToBootstrapClassLoaderSearch, // AddToBootstrapClassLoaderSearch
1586 _Jv_JVMTI_SetVerboseFlag, // SetVerboseFlag
1587 RESERVED, // reserved151
1588 RESERVED, // reserved152
1589 RESERVED, // reserved153
1590 _Jv_JVMTI_GetObjectSize // GetObjectSize
1594 _Jv_GetJVMTIEnv (void)
1597 = (_Jv_JVMTIEnv *) _Jv_MallocUnchecked (sizeof (_Jv_JVMTIEnv));
1598 env->p = &_Jv_JVMTI_Interface;
1601 JvSynchronize dummy (_envListLock);
1602 struct jvmti_env_list *element
1603 = (struct jvmti_env_list *) _Jv_MallocUnchecked (sizeof (struct jvmti_env_list));
1605 element->next = NULL;
1607 if (_jvmtiEnvironments == NULL)
1608 _jvmtiEnvironments = element;
1611 struct jvmti_env_list *e;
1612 for (e = _jvmtiEnvironments; e->next != NULL; e = e->next)
1624 _jvmtiEnvironments = NULL;
1625 _envListLock = new java::lang::Object ();
1627 // No environments, so this should set all JVMTI:: members to false
1628 check_enabled_events ();
1632 post_event (jvmtiEnv *env, jvmtiEvent type, jthread event_thread, va_list args)
1634 #define ARG(Type,Name) Type Name = (Type) va_arg (args, Type)
1636 #define GET_BOOLEAN_ARG(Name) \
1638 jboolean Name = (b == 0) ? false : true
1640 #define GET_CHAR_ARG(Name) \
1642 char Name = static_cast<char> (c)
1646 case JVMTI_EVENT_VM_INIT:
1647 if (env->callbacks.VMInit != NULL)
1649 ARG (JNIEnv *, jni_env);
1650 env->callbacks.VMInit (env, jni_env, event_thread);
1654 case JVMTI_EVENT_VM_DEATH:
1655 if (env->callbacks.VMDeath != NULL)
1657 ARG (JNIEnv *, jni_env);
1658 env->callbacks.VMDeath (env, jni_env);
1662 case JVMTI_EVENT_THREAD_START:
1663 if (env->callbacks.ThreadStart != NULL)
1665 ARG (JNIEnv *, jni_env);
1666 env->callbacks.ThreadStart (env, jni_env, event_thread);
1670 case JVMTI_EVENT_THREAD_END:
1671 if (env->callbacks.ThreadEnd != NULL)
1673 ARG (JNIEnv *, jni_env);
1674 env->callbacks.ThreadEnd (env, jni_env, event_thread);
1678 case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
1679 if (env->callbacks.ClassFileLoadHook != NULL)
1681 ARG (JNIEnv *, jni_env);
1682 ARG (jclass, class_being_redefined);
1683 ARG (jobject, loader);
1684 ARG (const char *, name);
1685 ARG (jobject, protection_domain);
1686 ARG (jint, class_data_len);
1687 ARG (const unsigned char *, class_data);
1688 ARG (jint *, new_class_data_len);
1689 ARG (unsigned char **, new_class_data);
1690 env->callbacks.ClassFileLoadHook (env, jni_env,
1691 class_being_redefined, loader,
1692 name, protection_domain,
1693 class_data_len, class_data,
1699 case JVMTI_EVENT_CLASS_LOAD:
1700 if (env->callbacks.ClassLoad != NULL)
1702 ARG (JNIEnv *, jni_env);
1703 ARG (jclass, klass);
1704 env->callbacks.ClassLoad (env, jni_env, event_thread, klass);
1708 case JVMTI_EVENT_CLASS_PREPARE:
1709 if (env->callbacks.ClassPrepare != NULL)
1711 ARG (JNIEnv *, jni_env);
1712 ARG (jclass, klass);
1713 env->callbacks.ClassPrepare (env, jni_env, event_thread, klass);
1717 case JVMTI_EVENT_VM_START:
1718 if (env->callbacks.VMStart != NULL)
1720 ARG (JNIEnv *, jni_env);
1721 env->callbacks.VMStart (env, jni_env);
1725 case JVMTI_EVENT_EXCEPTION:
1726 if (env->callbacks.Exception != NULL)
1728 ARG (JNIEnv *, jni_env);
1729 ARG (jmethodID, method);
1730 ARG (jlocation, location);
1731 ARG (jobject, exception);
1732 ARG (jmethodID, catch_method);
1733 ARG (jlocation, catch_location);
1734 env->callbacks.Exception (env, jni_env, event_thread, method,
1735 location, exception, catch_method,
1740 case JVMTI_EVENT_EXCEPTION_CATCH:
1741 if (env->callbacks.ExceptionCatch != NULL)
1743 ARG (JNIEnv *, jni_env);
1744 ARG (jmethodID, method);
1745 ARG (jlocation, location);
1746 ARG (jobject, exception);
1747 env->callbacks.ExceptionCatch (env, jni_env, event_thread, method,
1748 location, exception);
1752 case JVMTI_EVENT_SINGLE_STEP:
1753 if (env->callbacks.SingleStep != NULL)
1755 ARG (JNIEnv *, jni_env);
1756 ARG (jmethodID, method);
1757 ARG (jlocation, location);
1758 env->callbacks.SingleStep (env, jni_env, event_thread, method,
1763 case JVMTI_EVENT_FRAME_POP:
1764 if (env->callbacks.FramePop != NULL)
1766 ARG (JNIEnv *, jni_env);
1767 ARG (jmethodID, method);
1768 GET_BOOLEAN_ARG (was_popped_by_exception);
1769 env->callbacks.FramePop (env, jni_env, event_thread, method,
1770 was_popped_by_exception);
1774 case JVMTI_EVENT_BREAKPOINT:
1775 if (env->callbacks.Breakpoint != NULL)
1777 ARG (JNIEnv *, jni_env);
1778 ARG (jmethodID, method);
1779 ARG (jlocation, location);
1780 env->callbacks.Breakpoint (env, jni_env, event_thread, method,
1785 case JVMTI_EVENT_FIELD_ACCESS:
1786 if (env->callbacks.FieldAccess != NULL)
1788 ARG (JNIEnv *, jni_env);
1789 ARG (jmethodID, method);
1790 ARG (jlocation, location);
1791 ARG (jclass, field_class);
1792 ARG (jobject, object);
1793 ARG (jfieldID, field);
1794 env->callbacks.FieldAccess (env, jni_env, event_thread, method,
1795 location, field_class, object, field);
1799 case JVMTI_EVENT_FIELD_MODIFICATION:
1800 if (env->callbacks.FieldModification != NULL)
1802 ARG (JNIEnv *, jni_env);
1803 ARG (jmethodID, method);
1804 ARG (jlocation, location);
1805 ARG (jclass, field_class);
1806 ARG (jobject, object);
1807 ARG (jfieldID, field);
1808 GET_CHAR_ARG (signature_type);
1809 ARG (jvalue, new_value);
1810 env->callbacks.FieldModification (env, jni_env, event_thread, method,
1811 location, field_class, object,
1812 field, signature_type, new_value);
1816 case JVMTI_EVENT_METHOD_ENTRY:
1817 if (env->callbacks.MethodEntry != NULL)
1819 ARG (JNIEnv *, jni_env);
1820 ARG (jmethodID, method);
1821 env->callbacks.MethodEntry (env, jni_env, event_thread, method);
1825 case JVMTI_EVENT_METHOD_EXIT:
1826 if (env->callbacks.MethodExit != NULL)
1828 ARG (JNIEnv *, jni_env);
1829 ARG (jmethodID, method);
1830 GET_BOOLEAN_ARG (was_popped_by_exception);
1831 ARG (jvalue, return_value);
1832 env->callbacks.MethodExit (env, jni_env, event_thread, method,
1833 was_popped_by_exception, return_value);
1837 case JVMTI_EVENT_NATIVE_METHOD_BIND:
1838 if (env->callbacks.NativeMethodBind != NULL)
1840 ARG (JNIEnv *, jni_env);
1841 ARG (jmethodID, method);
1842 ARG (void *, address);
1843 ARG (void **, new_address_ptr);
1844 env->callbacks.NativeMethodBind (env, jni_env, event_thread, method,
1845 address, new_address_ptr);
1849 case JVMTI_EVENT_COMPILED_METHOD_LOAD:
1850 if (env->callbacks.CompiledMethodLoad != NULL)
1852 ARG (jmethodID, method);
1853 ARG (jint, code_size);
1854 ARG (const void *, code_addr);
1855 ARG (jint, map_length);
1856 ARG (const jvmtiAddrLocationMap *, map);
1857 ARG (const void *, compile_info);
1858 env->callbacks.CompiledMethodLoad (env, method, code_size, code_addr,
1859 map_length, map, compile_info);
1863 case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
1864 if (env->callbacks.CompiledMethodUnload != NULL)
1866 ARG (jmethodID, method);
1867 ARG (const void *, code_addr);
1868 env->callbacks.CompiledMethodUnload (env, method, code_addr);
1872 case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
1873 if (env->callbacks.DynamicCodeGenerated != NULL)
1875 ARG (const char *, name);
1876 ARG (const void *, address);
1878 env->callbacks.DynamicCodeGenerated (env, name, address, length);
1882 case JVMTI_EVENT_DATA_DUMP_REQUEST:
1883 if (env->callbacks.DataDumpRequest != NULL)
1885 env->callbacks.DataDumpRequest (env);
1889 case JVMTI_EVENT_MONITOR_WAIT:
1890 if (env->callbacks.MonitorWait != NULL)
1892 ARG (JNIEnv *, jni_env);
1893 ARG (jobject, object);
1894 ARG (jlong, timeout);
1895 env->callbacks.MonitorWait (env, jni_env, event_thread, object,
1900 case JVMTI_EVENT_MONITOR_WAITED:
1901 if (env->callbacks.MonitorWaited != NULL)
1903 ARG (JNIEnv *, jni_env);
1904 ARG (jobject, object);
1905 GET_BOOLEAN_ARG (timed_out);
1906 env->callbacks.MonitorWaited (env, jni_env, event_thread, object,
1911 case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
1912 if (env->callbacks.MonitorContendedEnter != NULL)
1914 ARG (JNIEnv *, jni_env);
1915 ARG (jobject, object);
1916 env->callbacks.MonitorContendedEnter (env, jni_env, event_thread,
1921 case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
1922 if (env->callbacks.MonitorContendedEntered != NULL)
1924 ARG (JNIEnv *, jni_env);
1925 ARG (jobject, object);
1926 env->callbacks.MonitorContendedEntered (env, jni_env, event_thread,
1931 case JVMTI_EVENT_GARBAGE_COLLECTION_START:
1932 if (env->callbacks.GarbageCollectionStart != NULL)
1934 env->callbacks.GarbageCollectionStart (env);
1938 case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
1939 if (env->callbacks.GarbageCollectionFinish != NULL)
1941 env->callbacks.GarbageCollectionFinish (env);
1945 case JVMTI_EVENT_OBJECT_FREE:
1946 if (env->callbacks.ObjectFree != NULL)
1949 env->callbacks.ObjectFree (env, tag);
1953 case JVMTI_EVENT_VM_OBJECT_ALLOC:
1954 if (env->callbacks.VMObjectAlloc != NULL)
1956 ARG (JNIEnv *, jni_env);
1957 ARG (jobject, object);
1958 ARG (jclass, object_class);
1960 env->callbacks.VMObjectAlloc (env, jni_env, event_thread,
1961 object, object_class, size);
1966 fprintf (stderr, "libgcj: post of unknown JVMTI event (%d)\n",
1972 #undef GET_BOOLEAN_ARG
1976 /* Post an event to requesting JVMTI environments
1978 * This function should not be called without consulting the
1979 * JVMTI_REQUESTED_EVENT macro first (for speed). It does no real
1980 * harm (other than kill speed), since this function will still
1981 * only send the event if it was properly requested by an environment.
1984 _Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...)
1987 va_start (args, event_thread);
1989 JvSynchronize dummy (_envListLock);
1990 struct jvmti_env_list *e;
1991 FOREACH_ENVIRONMENT (e)
1993 /* Events are only posted if the event was explicitly enabled,
1994 it has a registered event handler, and the event thread
1995 matches (either globally or restricted to a specific thread).
1996 Here we check all but the event handler, which will be handled
1998 if (e->env->enabled[EVENT_INDEX(type)]
1999 && (e->env->thread[EVENT_INDEX(type)] == NULL
2000 || e->env->thread[EVENT_INDEX(type)] == event_thread))
2002 post_event (e->env, type, event_thread, args);