Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-12-27 07:31:35 +00:00
Code Issues Projects Releases Wiki Activity
54d890514a
Retro68/gcc/libjava/jvmti.cc
Wolfgang Thaller aaf905ce07 add gcc 4.70
2012-03-28 01:13:14 +02:00

2627 lines
71 KiB
C++
Raw Blame History

// jvmti.cc - JVMTI implementation
/* Copyright (C) 2006, 2007, 2010 Free Software Foundation
This file is part of libgcj.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
#include <config.h>
#include <platform.h>
#include <jvm.h>
#include <java-threads.h>
#include <java-gc.h>
#include <java-interp.h>
#include <jvmti.h>
#include "jvmti-int.h"
#include <gcj/method.h>
#include <gnu/classpath/SystemProperties.h>
#include <gnu/gcj/runtime/BootClassLoader.h>
#include <gnu/gcj/jvmti/Breakpoint.h>
#include <gnu/gcj/jvmti/BreakpointManager.h>
#include <java/lang/Class.h>
#include <java/lang/ClassLoader.h>
#include <java/lang/OutOfMemoryError.h>
#include <java/lang/Thread.h>
#include <java/lang/ThreadGroup.h>
#include <java/lang/Thread$State.h>
#include <java/lang/Throwable.h>
#include <java/lang/VMClassLoader.h>
#include <java/lang/reflect/Field.h>
#include <java/lang/reflect/Modifier.h>
#include <java/util/Collection.h>
#include <java/util/HashMap.h>
#include <java/util/concurrent/locks/Lock.h>
#include <java/util/concurrent/locks/ReentrantReadWriteLock.h>
#include <java/net/URL.h>
static void check_enabled_events (void);
static void check_enabled_event (jvmtiEvent);
namespace JVMTI
{
// Is JVMTI enabled? (i.e., any jvmtiEnv created?)
bool enabled;
// Event notifications
bool VMInit = false;
bool VMDeath = false;
bool ThreadStart = false;
bool ThreadEnd = false;
bool ClassFileLoadHook = false;
bool ClassLoad = false;
bool ClassPrepare = false;
bool VMStart = false;
bool Exception = false;
bool ExceptionCatch = false;
bool SingleStep = false;
bool FramePop = false;
bool Breakpoint = false;
bool FieldAccess = false;
bool FieldModification = false;
bool MethodEntry = false;
bool MethodExit = false;
bool NativeMethodBind = false;
bool CompiledMethodLoad = false;
bool CompiledMethodUnload = false;
bool DynamicCodeGenerated = false;
bool DataDumpRequest = false;
bool reserved72 = false;
bool MonitorWait = false;
bool MonitorWaited = false;
bool MonitorContendedEnter = false;
bool MonitorContendedEntered = false;
bool reserved77 = false;
bool reserved78 = false;
bool reserved79 = false;
bool reserved80 = false;
bool GarbageCollectionStart = false;
bool GarbageCollectionFinish = false;
bool ObjectFree = false;
bool VMObjectAlloc = false;
};
extern struct JNINativeInterface _Jv_JNIFunctions;
struct _Jv_rawMonitorID
{
_Jv_Mutex_t mutex;
_Jv_ConditionVariable_t condition;
};
/* A simple linked list of all JVMTI environments. Since
events must be delivered to environments in the order
in which the environments were created, new environments
are added to the end of the list. */
struct jvmti_env_list
{
jvmtiEnv *env;
struct jvmti_env_list *next;
};
static struct jvmti_env_list *_jvmtiEnvironments = NULL;
static java::util::concurrent::locks::
ReentrantReadWriteLock *_envListLock = NULL;
#define FOREACH_ENVIRONMENT(Ele) \
for (Ele = _jvmtiEnvironments; Ele != NULL; Ele = Ele->next)
// Some commonly-used checks
#define THREAD_DEFAULT_TO_CURRENT(Ajthread) \
do \
{ \
if (Ajthread == NULL) \
Ajthread = java::lang::Thread::currentThread (); \
} \
while (0)
#define THREAD_CHECK_VALID(Athread) \
do \
{ \
if (!java::lang::Thread::class$.isAssignableFrom (&(Athread->class$))) \
return JVMTI_ERROR_INVALID_THREAD; \
} \
while (0)
#define THREAD_CHECK_IS_ALIVE(Athread) \
do \
{ \
if (!Athread->isAlive ()) \
return JVMTI_ERROR_THREAD_NOT_ALIVE; \
} \
while (0)
// FIXME: if current phase is not set in Phases,
// return JVMTI_ERROR_WRONG_PHASE
#define REQUIRE_PHASE(Env, Phases)
#define NULL_CHECK(Ptr) \
do \
{ \
if (Ptr == NULL) \
return JVMTI_ERROR_NULL_POINTER; \
} \
while (0)
#define ILLEGAL_ARGUMENT(Cond) \
do \
{ \
if ((Cond)) \
return JVMTI_ERROR_ILLEGAL_ARGUMENT; \
} \
while (0)
#define CHECK_FOR_NATIVE_METHOD(AjmethodID) \
do \
{ \
jboolean is_native; \
jvmtiError jerr = env->IsMethodNative (AjmethodID, &is_native); \
if (jerr != JVMTI_ERROR_NONE) \
return jerr; \
if (is_native) \
return JVMTI_ERROR_NATIVE_METHOD; \
} \
while (0)
static jvmtiError JNICALL
_Jv_JVMTI_SuspendThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
{
using namespace java::lang;
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
_Jv_Thread_t *data = _Jv_ThreadGetData (thread);
_Jv_SuspendThread (data);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_ResumeThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
{
using namespace java::lang;
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
_Jv_Thread_t *data = _Jv_ThreadGetData (thread);
_Jv_ResumeThread (data);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_InterruptThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
{
using namespace java::lang;
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
// FIXME: capability handling? 'can_signal_thread'
if (thread == NULL)
return JVMTI_ERROR_INVALID_THREAD;
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
thread->interrupt();
return JVMTI_ERROR_NONE;
}
// This method performs the common tasks to get and set variables of all types.
// It is called by the _Jv_JVMTI_Get/SetLocalInt/Object/.... methods.
static jvmtiError
getLocalFrame (jvmtiEnv *env, jthread thread, jint depth, jint slot, char type,
_Jv_InterpFrame **iframe)
{
using namespace java::lang;
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
ILLEGAL_ARGUMENT (depth < 0);
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
_Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
for (int i = 0; i < depth; i++)
{
frame = frame->next;
if (frame == NULL)
return JVMTI_ERROR_NO_MORE_FRAMES;
}
if (frame->frame_type == frame_native)
return JVMTI_ERROR_OPAQUE_FRAME;
jint max_locals;
jvmtiError jerr = env->GetMaxLocals (reinterpret_cast<jmethodID>
(frame->self->get_method ()),
&max_locals);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
_Jv_InterpFrame *tmp_iframe = reinterpret_cast<_Jv_InterpFrame *> (frame);
// The second slot taken up by a long type is marked as type 'x' meaning it
// is not valid for access since it holds only the 4 low bytes of the value.
if (tmp_iframe->locals_type[slot] == 'x')
return JVMTI_ERROR_INVALID_SLOT;
if (tmp_iframe->locals_type[slot] != type)
return JVMTI_ERROR_TYPE_MISMATCH;
// Check for invalid slots, if the type is a long type, we must check that
// the next slot is valid as well.
if (slot < 0 || slot >= max_locals
|| ((type == 'l' || type == 'd') && slot + 1 >= max_locals))
return JVMTI_ERROR_INVALID_SLOT;
*iframe = tmp_iframe;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalObject (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jobject *value)
{
NULL_CHECK (value);
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'o', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
*value = frame->locals[slot].o;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetLocalObject (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jobject value)
{
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'o', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
frame->locals[slot].o = value;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalInt (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jint *value)
{
NULL_CHECK (value);
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'i', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
*value = frame->locals[slot].i;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetLocalInt (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jint value)
{
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'i', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
frame->locals[slot].i = value;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalLong (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jlong *value)
{
NULL_CHECK (value);
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'l', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
#if SIZEOF_VOID_P==8
*value = frame->locals[slot].l;
#else
_Jv_word2 val;
val.ia[0] = frame->locals[slot].ia[0];
val.ia[1] = frame->locals[slot + 1].ia[0];
*value = val.l;
#endif
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetLocalLong (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jlong value)
{
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'l', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
#if SIZEOF_VOID_P==8
frame->locals[slot].l = value;
#else
_Jv_word2 val;
val.l = value;
frame->locals[slot].ia[0] = val.ia[0];
frame->locals[slot + 1].ia[0] = val.ia[1];
#endif
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalFloat (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jfloat *value)
{
NULL_CHECK (value);
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'f', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
*value = frame->locals[slot].f;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetLocalFloat (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jfloat value)
{
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'f', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
frame->locals[slot].f = value;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalDouble (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jdouble *value)
{
NULL_CHECK (value);
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'd', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
#if SIZEOF_VOID_P==8
*value = frame->locals[slot].d;
#else
_Jv_word2 val;
val.ia[0] = frame->locals[slot].ia[0];
val.ia[1] = frame->locals[slot + 1].ia[0];
*value = val.d;
#endif
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetLocalDouble (jvmtiEnv *env, jthread thread, jint depth, jint slot,
jdouble value)
{
_Jv_InterpFrame *frame;
jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'd', &frame);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
#if SIZEOF_VOID_P==8
frame->locals[slot].d = value;
#else
_Jv_word2 val;
val.d = value;
frame->locals[slot].ia[0] = val.ia[0];
frame->locals[slot + 1].ia[0] = val.ia[1];
#endif
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetAllThreads(MAYBE_UNUSED jvmtiEnv *env, jint *thread_cnt,
jthread **threads)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
NULL_CHECK (thread_cnt);
NULL_CHECK (threads);
using namespace java::lang;
ThreadGroup *root_grp = ThreadGroup::root;
jint estimate = root_grp->activeCount ();
JArray<Thread *> *thr_arr;
// Allocate some extra space since threads can be created between calls
try
{
thr_arr = reinterpret_cast<JArray<Thread *> *> (JvNewObjectArray
((estimate * 2),
&Thread::class$, NULL));
}
catch (java::lang::OutOfMemoryError *err)
{
return JVMTI_ERROR_OUT_OF_MEMORY;
}
*thread_cnt = root_grp->enumerate (thr_arr);
jvmtiError jerr = env->Allocate ((jlong) ((*thread_cnt) * sizeof (jthread)),
(unsigned char **) threads);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
// Transfer the threads to the result array
jthread *tmp_arr = reinterpret_cast<jthread *> (elements (thr_arr));
memcpy ((*threads), tmp_arr, (*thread_cnt));
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetFrameCount (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
jint *frame_count)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
NULL_CHECK (frame_count);
using namespace java::lang;
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
_Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
(*frame_count) = frame->depth ();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetThreadState (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
jint *thread_state_ptr)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
NULL_CHECK (thread_state_ptr);
jint state = 0;
if (thread->isAlive ())
{
state |= JVMTI_THREAD_STATE_ALIVE;
_Jv_Thread_t *data = _Jv_ThreadGetData (thread);
if (_Jv_IsThreadSuspended (data))
state |= JVMTI_THREAD_STATE_SUSPENDED;
if (thread->isInterrupted ())
state |= JVMTI_THREAD_STATE_INTERRUPTED;
_Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
if (frame != NULL && frame->frame_type == frame_native)
state |= JVMTI_THREAD_STATE_IN_NATIVE;
using namespace java::lang;
Thread$State *ts = thread->getState ();
if (ts == Thread$State::RUNNABLE)
state |= JVMTI_THREAD_STATE_RUNNABLE;
else if (ts == Thread$State::BLOCKED)
state |= JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER;
else if (ts == Thread$State::TIMED_WAITING
|| ts == Thread$State::WAITING)
{
state |= JVMTI_THREAD_STATE_WAITING;
state |= ((ts == Thread$State::WAITING)
? JVMTI_THREAD_STATE_WAITING_INDEFINITELY
: JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT);
/* FIXME: We don't have a way to tell
the caller why the thread is suspended,
i.e., JVMTI_THREAD_STATE_SLEEPING,
JVMTI_THREAD_STATE_PARKED, and
JVMTI_THREAD_STATE_IN_OBJECT_WAIT
are never set. */
}
}
else
{
using namespace java::lang;
Thread$State *ts = thread->getState ();
if (ts == Thread$State::TERMINATED)
state |= JVMTI_THREAD_STATE_TERMINATED;
}
*thread_state_ptr = state;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_CreateRawMonitor (MAYBE_UNUSED jvmtiEnv *env, const char *name,
jrawMonitorID *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
NULL_CHECK (name);
NULL_CHECK (result);
*result = (jrawMonitorID) _Jv_MallocUnchecked (sizeof (_Jv_rawMonitorID));
if (*result == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
_Jv_MutexInit (&(*result)->mutex);
_Jv_CondInit (&(*result)->condition);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_DestroyRawMonitor (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
// Note we have no better way of knowing whether this object is
// really a raw monitor.
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
// FIXME: perform checks on monitor, release it if this thread owns
// it.
#ifdef _Jv_HaveMutexDestroy
_Jv_MutexDestroy (&monitor->mutex);
#endif
_Jv_Free (monitor);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_RawMonitorEnter (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
{
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
_Jv_MutexLock (&monitor->mutex);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_RawMonitorExit (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
{
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
if (_Jv_MutexUnlock (&monitor->mutex))
return JVMTI_ERROR_NOT_MONITOR_OWNER;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_RawMonitorWait (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor,
jlong millis)
{
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
int r = _Jv_CondWait (&monitor->condition, &monitor->mutex, millis, 0);
if (r == _JV_NOT_OWNER)
return JVMTI_ERROR_NOT_MONITOR_OWNER;
if (r == _JV_INTERRUPTED)
return JVMTI_ERROR_INTERRUPT;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_RawMonitorNotify (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
{
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
if (_Jv_CondNotify (&monitor->condition, &monitor->mutex) == _JV_NOT_OWNER)
return JVMTI_ERROR_NOT_MONITOR_OWNER;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_RawMonitorNotifyAll (MAYBE_UNUSED jvmtiEnv *env,
jrawMonitorID monitor)
{
if (monitor == NULL)
return JVMTI_ERROR_INVALID_MONITOR;
if (_Jv_CondNotifyAll (&monitor->condition, &monitor->mutex)
== _JV_NOT_OWNER)
return JVMTI_ERROR_NOT_MONITOR_OWNER;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetBreakpoint (jvmtiEnv *env, jmethodID method, jlocation location)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
using namespace gnu::gcj::jvmti;
Breakpoint *bp
= BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
location);
if (bp == NULL)
{
jclass klass;
jvmtiError err = env->GetMethodDeclaringClass (method, &klass);
if (err != JVMTI_ERROR_NONE)
return err;
if (!_Jv_IsInterpretedClass (klass))
return JVMTI_ERROR_INVALID_CLASS;
_Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
if (base == NULL)
return JVMTI_ERROR_INVALID_METHODID;
jint flags;
err = env->GetMethodModifiers (method, &flags);
if (err != JVMTI_ERROR_NONE)
return err;
if (flags & java::lang::reflect::Modifier::NATIVE)
return JVMTI_ERROR_NATIVE_METHOD;
_Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
if (imeth->get_insn (location) == NULL)
return JVMTI_ERROR_INVALID_LOCATION;
// Now the breakpoint can be safely installed
bp = BreakpointManager::newBreakpoint (reinterpret_cast<jlong> (method),
location);
}
else
{
// Duplicate breakpoints are not permitted by JVMTI
return JVMTI_ERROR_DUPLICATE;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_ClearBreakpoint (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
jlocation location)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
using namespace gnu::gcj::jvmti;
Breakpoint *bp
= BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
location);
if (bp == NULL)
return JVMTI_ERROR_NOT_FOUND;
BreakpointManager::deleteBreakpoint (reinterpret_cast<jlong> (method), location);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_Allocate (MAYBE_UNUSED jvmtiEnv *env, jlong size,
unsigned char **result)
{
ILLEGAL_ARGUMENT (size < 0);
NULL_CHECK (result);
if (size == 0)
*result = NULL;
else
{
*result = (unsigned char *) _Jv_MallocUnchecked (size);
if (*result == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_Deallocate (MAYBE_UNUSED jvmtiEnv *env, unsigned char *mem)
{
if (mem != NULL)
_Jv_Free (mem);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetClassStatus (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jint *status_ptr)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
NULL_CHECK (status_ptr);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
if (klass->isArray ())
*status_ptr = JVMTI_CLASS_STATUS_ARRAY;
else if (klass->isPrimitive ())
*status_ptr = JVMTI_CLASS_STATUS_PRIMITIVE;
else
{
jbyte state = _Jv_GetClassState (klass);
*status_ptr = 0;
if (state >= JV_STATE_LINKED)
(*status_ptr) |= JVMTI_CLASS_STATUS_VERIFIED;
if (state >= JV_STATE_PREPARED)
(*status_ptr) |= JVMTI_CLASS_STATUS_PREPARED;
if (state == JV_STATE_ERROR || state == JV_STATE_PHANTOM)
(*status_ptr) |= JVMTI_CLASS_STATUS_ERROR;
else if (state == JV_STATE_DONE)
(*status_ptr) |= JVMTI_CLASS_STATUS_INITIALIZED;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetClassModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jint *mods)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
// Don't bother checking KLASS' type.
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
NULL_CHECK (mods);
*mods = klass->getModifiers();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetClassMethods (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jint *count_ptr, jmethodID **methods_ptr)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
// FIXME: capability can_maintain_original_method_order
// Don't bother checking KLASS' type.
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
NULL_CHECK (count_ptr);
NULL_CHECK (methods_ptr);
*count_ptr = JvNumMethods(klass);
*methods_ptr
= (jmethodID *) _Jv_MallocUnchecked (*count_ptr * sizeof (jmethodID));
if (*methods_ptr == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
jmethodID start = JvGetFirstMethod (klass);
for (jint i = 0; i < *count_ptr; ++i)
// FIXME: correct?
(*methods_ptr)[i] = start + i;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_IsInterface (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jboolean *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
NULL_CHECK (result);
*result = klass->isInterface();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_IsArrayClass (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jboolean *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
NULL_CHECK (result);
*result = klass->isArray();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetClassLoader (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jobject *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
NULL_CHECK (result);
*result = klass->getClassLoaderInternal();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetObjectHashCode (MAYBE_UNUSED jvmtiEnv *env, jobject obj,
jint *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (obj == NULL)
return JVMTI_ERROR_INVALID_OBJECT;
NULL_CHECK (result);
*result = _Jv_HashCode (obj);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetFieldModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jfieldID field, jint *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
if (field == NULL)
return JVMTI_ERROR_INVALID_FIELDID;
NULL_CHECK (result);
*result = field->getModifiers();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_IsFieldSynthetic (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
jfieldID field, jboolean *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (klass == NULL)
return JVMTI_ERROR_INVALID_CLASS;
if (field == NULL)
return JVMTI_ERROR_INVALID_FIELDID;
NULL_CHECK (result);
// FIXME: capability can_get_synthetic_attribute
*result = ((field->getModifiers() & java::lang::reflect::Modifier::SYNTHETIC)
!= 0);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetMethodName (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
char **name_ptr, char **signature_ptr,
char **generic_ptr)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (method == NULL)
return JVMTI_ERROR_INVALID_METHODID;
if (name_ptr != NULL)
{
int len = static_cast<int> (method->name->len ());
*name_ptr = (char *) _Jv_MallocUnchecked (len + 1);
if (*name_ptr == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
strncpy (*name_ptr, method->name->chars (), len);
(*name_ptr)[len] = '\0';
}
if (signature_ptr != NULL)
{
int len = static_cast<int> (method->signature->len ());
*signature_ptr = (char *) _Jv_MallocUnchecked (len + 1);
if (*signature_ptr == NULL)
{
if (name_ptr != NULL)
_Jv_Free (*name_ptr);
return JVMTI_ERROR_OUT_OF_MEMORY;
}
strncpy (*signature_ptr, method->signature->chars (), len);
(*signature_ptr)[len] = '\0';
}
if (generic_ptr != NULL)
{
*generic_ptr = NULL;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetMethodModifiers (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
jint *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (method == NULL)
return JVMTI_ERROR_INVALID_METHODID;
NULL_CHECK (result);
// FIXME: mask off some internal bits...
*result = method->accflags;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLineNumberTable (jvmtiEnv *env, jmethodID method,
jint *entry_count_ptr,
jvmtiLineNumberEntry **table_ptr)
{
NULL_CHECK (entry_count_ptr);
NULL_CHECK (table_ptr);
jclass klass;
jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
_Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
if (base == NULL)
return JVMTI_ERROR_INVALID_METHODID;
if (java::lang::reflect::Modifier::isNative (method->accflags)
|| !_Jv_IsInterpretedClass (klass))
return JVMTI_ERROR_NATIVE_METHOD;
_Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
jlong start, end;
jintArray lines = NULL;
jlongArray indices = NULL;
imeth->get_line_table (start, end, lines, indices);
if (lines == NULL)
return JVMTI_ERROR_ABSENT_INFORMATION;
jvmtiLineNumberEntry *table;
jsize len = lines->length * sizeof (jvmtiLineNumberEntry);
table = (jvmtiLineNumberEntry *) _Jv_MallocUnchecked (len);
if (table == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
jint *line = elements (lines);
jlong *index = elements (indices);
for (int i = 0; i < lines->length; ++i)
{
table[i].start_location = index[i];
table[i].line_number = line[i];
}
*table_ptr = table;
*entry_count_ptr = lines->length;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetLocalVariableTable (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
jint *num_locals,
jvmtiLocalVariableEntry **locals)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
NULL_CHECK (num_locals);
NULL_CHECK (locals);
CHECK_FOR_NATIVE_METHOD(method);
jclass klass;
jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
_Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *>
(_Jv_FindInterpreterMethod (klass, method));
if (imeth == NULL)
return JVMTI_ERROR_INVALID_METHODID;
jerr = env->GetMaxLocals (method, num_locals);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
jerr = env->Allocate (static_cast<jlong>
((*num_locals) * sizeof (jvmtiLocalVariableEntry)),
reinterpret_cast<unsigned char **> (locals));
if (jerr != JVMTI_ERROR_NONE)
return jerr;
//the slot in the methods local_var_table to get
int table_slot = 0;
char *name;
char *sig;
char *generic_sig;
while (table_slot < *num_locals
&& imeth->get_local_var_table (&name, &sig, &generic_sig,
&((((*locals)[table_slot].start_location))),
&((*locals)[table_slot].length),
&((*locals)[table_slot].slot),
table_slot)
>= 0)
{
char **str_ptr = &(*locals)[table_slot].name;
jerr = env->Allocate (static_cast<jlong> (strlen (name) + 1),
reinterpret_cast<unsigned char **> (str_ptr));
if (jerr != JVMTI_ERROR_NONE)
return jerr;
strcpy ((*locals)[table_slot].name, name);
str_ptr = &(*locals)[table_slot].signature;
jerr = env->Allocate (static_cast<jlong> (strlen (sig) + 1),
reinterpret_cast<unsigned char **> (str_ptr));
if (jerr != JVMTI_ERROR_NONE)
return jerr;
strcpy ((*locals)[table_slot].signature, sig);
str_ptr = &(*locals)[table_slot].generic_signature;
jerr = env->Allocate (static_cast<jlong> (strlen (generic_sig) + 1),
reinterpret_cast<unsigned char **> (str_ptr));
if (jerr != JVMTI_ERROR_NONE)
return jerr;
strcpy ((*locals)[table_slot].generic_signature, generic_sig);
table_slot++;
}
if (table_slot == 0)
return JVMTI_ERROR_ABSENT_INFORMATION;
// If there are double or long variables in the table, the the table will be
// smaller than the max number of slots, so correct for this here.
if ((table_slot) < *num_locals)
*num_locals = table_slot;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_IsMethodNative (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
jboolean *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (method == NULL)
return JVMTI_ERROR_INVALID_METHODID;
NULL_CHECK (result);
*result = ((method->accflags & java::lang::reflect::Modifier::NATIVE) != 0);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_IsMethodSynthetic (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
jboolean *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (method == NULL)
return JVMTI_ERROR_INVALID_METHODID;
NULL_CHECK (result);
// FIXME capability can_get_synthetic_attribute
*result = ((method->accflags & java::lang::reflect::Modifier::SYNTHETIC)
!= 0);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetMaxLocals (jvmtiEnv *env, jmethodID method, jint *max_locals)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
NULL_CHECK (max_locals);
CHECK_FOR_NATIVE_METHOD (method);
jclass klass;
jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
_Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *>
(_Jv_FindInterpreterMethod (klass, method));
if (imeth == NULL)
return JVMTI_ERROR_INVALID_METHODID;
*max_locals = imeth->get_max_locals ();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetArgumentsSize (jvmtiEnv *env, jmethodID method, jint *size)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
NULL_CHECK (size);
CHECK_FOR_NATIVE_METHOD (method);
jvmtiError jerr;
char *sig;
jint num_slots = 0;
jerr = env->GetMethodName (method, NULL, &sig, NULL);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
// If the method is non-static add a slot for the "this" pointer.
if ((method->accflags & java::lang::reflect::Modifier::STATIC) == 0)
num_slots++;
for (int i = 0; sig[i] != ')'; i++)
{
if (sig[i] == 'Z' || sig[i] == 'B' || sig[i] == 'C' || sig[i] == 'S'
|| sig[i] == 'I' || sig[i] == 'F')
num_slots++;
else if (sig[i] == 'J' || sig[i] == 'D')
{
// If this is an array of wide types it uses a single slot
if (i > 0 && sig[i - 1] == '[')
num_slots++;
else
num_slots += 2;
}
else if (sig[i] == 'L')
{
num_slots++;
while (sig[i] != ';')
i++;
}
}
*size = num_slots;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetMethodDeclaringClass (MAYBE_UNUSED jvmtiEnv *env,
jmethodID method,
jclass *declaring_class_ptr)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
NULL_CHECK (declaring_class_ptr);
jclass klass = _Jv_GetMethodDeclaringClass (method);
if (klass != NULL)
{
*declaring_class_ptr = klass;
return JVMTI_ERROR_NONE;
}
return JVMTI_ERROR_INVALID_METHODID;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetClassLoaderClasses (MAYBE_UNUSED jvmtiEnv *env,
jobject init_loader,
jint *count_ptr,
jclass **result_ptr)
{
using namespace java::lang;
using namespace java::util;
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
NULL_CHECK (count_ptr);
NULL_CHECK (result_ptr);
ClassLoader *loader = (ClassLoader *) init_loader;
if (loader == NULL)
loader = VMClassLoader::bootLoader;
Collection *values = loader->loadedClasses->values();
jobjectArray array = values->toArray();
*count_ptr = array->length;
jobject *elts = elements (array);
jclass *result
= (jclass *) _Jv_MallocUnchecked (*count_ptr * sizeof (jclass));
if (result == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
// FIXME: JNI references...
memcpy (result, elts, *count_ptr * sizeof (jclass));
*result_ptr = result;
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetStackTrace (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
jint start_depth, jint max_frames,
jvmtiFrameInfo *frames, jint *frame_count)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
ILLEGAL_ARGUMENT (max_frames < 0);
NULL_CHECK (frames);
NULL_CHECK (frame_count);
using namespace java::lang;
THREAD_DEFAULT_TO_CURRENT (thread);
THREAD_CHECK_VALID (thread);
THREAD_CHECK_IS_ALIVE (thread);
jvmtiError jerr = env->GetFrameCount (thread, frame_count);
if (jerr != JVMTI_ERROR_NONE)
return jerr;
// start_depth can be either a positive number, indicating the depth of the
// stack at which to begin the trace, or a negative number indicating the
// number of frames at the bottom of the stack to exclude. These checks
// ensure that it is a valid value in either case
ILLEGAL_ARGUMENT (start_depth >= (*frame_count));
ILLEGAL_ARGUMENT (start_depth < (-(*frame_count)));
_Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
// If start_depth is negative use this to determine at what depth to start
// the trace by adding it to the length of the call stack. This allows the
// use of the same frame "discarding" mechanism as for a positive start_depth
if (start_depth < 0)
start_depth = *frame_count + start_depth;
// If start_depth > 0 "remove" start_depth frames from the beginning
// of the stack before beginning the trace by moving along the frame list.
while (start_depth > 0)
{
frame = frame->next;
start_depth--;
(*frame_count)--;
}
// Now check to see if the array supplied by the agent is large enough to
// hold frame_count frames, after adjustment for start_depth.
if ((*frame_count) > max_frames)
(*frame_count) = max_frames;
for (int i = 0; i < (*frame_count); i++)
{
frames[i].method = frame->self->get_method ();
// Set the location in the frame, native frames have location = -1
if (frame->frame_type == frame_interpreter)
{
_Jv_InterpMethod *imeth
= static_cast<_Jv_InterpMethod *> (frame->self);
_Jv_InterpFrame *interp_frame
= static_cast<_Jv_InterpFrame *> (frame);
frames[i].location = imeth->insn_index (interp_frame->get_pc ());
}
else
frames[i].location = -1;
frame = frame->next;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_ForceGarbageCollection (MAYBE_UNUSED jvmtiEnv *env)
{
REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
_Jv_RunGC();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
const jniNativeInterface *function_table)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
NULL_CHECK (function_table);
memcpy (&_Jv_JNIFunctions, function_table, sizeof (jniNativeInterface));
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
jniNativeInterface **function_table)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
NULL_CHECK (function_table);
*function_table
= (jniNativeInterface *) _Jv_MallocUnchecked (sizeof (jniNativeInterface));
if (*function_table == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
memcpy (*function_table, &_Jv_JNIFunctions, sizeof (jniNativeInterface));
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env)
{
NULL_CHECK (env);
if (_jvmtiEnvironments == NULL)
return JVMTI_ERROR_INVALID_ENVIRONMENT;
else
{
_envListLock->writeLock ()->lock ();
if (_jvmtiEnvironments->env == env)
{
struct jvmti_env_list *next = _jvmtiEnvironments->next;
_Jv_Free (_jvmtiEnvironments);
_jvmtiEnvironments = next;
}
else
{
struct jvmti_env_list *e = _jvmtiEnvironments;
while (e->next != NULL && e->next->env != env)
e = e->next;
if (e->next == NULL)
{
_envListLock->writeLock ()->unlock ();
return JVMTI_ERROR_INVALID_ENVIRONMENT;
}
struct jvmti_env_list *next = e->next->next;
_Jv_Free (e->next);
e->next = next;
}
_envListLock->writeLock ()->unlock ();
}
_Jv_Free (env);
check_enabled_events ();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
char **result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
NULL_CHECK (property);
NULL_CHECK (result);
jstring name = JvNewStringUTF(property);
jstring result_str = gnu::classpath::SystemProperties::getProperty(name);
if (result_str == NULL)
return JVMTI_ERROR_NOT_AVAILABLE;
int len = JvGetStringUTFLength (result_str);
*result = (char *) _Jv_MallocUnchecked (len + 1);
if (*result == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
JvGetStringUTFRegion (result_str, 0, result_str->length(), *result);
(*result)[len] = '\0';
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
const char *value)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
NULL_CHECK (property);
if (value == NULL)
{
// FIXME: When would a property not be writeable?
return JVMTI_ERROR_NONE;
}
jstring prop_str = JvNewStringUTF(property);
jstring value_str = JvNewStringUTF(value);
gnu::classpath::SystemProperties::setProperty(prop_str, value_str);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetTime (MAYBE_UNUSED jvmtiEnv *env, jlong *nanos_ptr)
{
NULL_CHECK (nanos_ptr);
*nanos_ptr = _Jv_platform_nanotime();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetAvailableProcessors (MAYBE_UNUSED jvmtiEnv *env,
jint *nprocessors_ptr)
{
NULL_CHECK (nprocessors_ptr);
#ifdef _SC_NPROCESSORS_ONLN
*nprocessors_ptr = sysconf(_SC_NPROCESSORS_ONLN);
#else
*nprocessors_ptr = 1;
#endif
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_AddToBootstrapClassLoaderSearch (MAYBE_UNUSED jvmtiEnv *env,
const char *segment)
{
using namespace java::lang;
using namespace java::net;
using namespace gnu::gcj::runtime;
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
NULL_CHECK (segment);
jstring str_segment = JvNewStringUTF(segment);
URL *url;
try
{
url = new URL(JvNewStringUTF("file"), NULL, str_segment);
}
catch (jthrowable ignore)
{
return JVMTI_ERROR_ILLEGAL_ARGUMENT;
}
BootClassLoader *loader = VMClassLoader::bootLoader;
// Don't call this too early.
// assert (loader != NULL);
loader->addURL(url);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetVerboseFlag (MAYBE_UNUSED jvmtiEnv *env, jvmtiVerboseFlag flag,
jboolean value)
{
switch (flag)
{
case JVMTI_VERBOSE_OTHER:
case JVMTI_VERBOSE_GC:
case JVMTI_VERBOSE_JNI:
// Ignore.
break;
case JVMTI_VERBOSE_CLASS:
gcj::verbose_class_flag = value;
break;
default:
return JVMTI_ERROR_ILLEGAL_ARGUMENT;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetObjectSize (MAYBE_UNUSED jvmtiEnv *env, jobject object,
jlong *result)
{
REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
if (object == NULL)
return JVMTI_ERROR_INVALID_OBJECT;
NULL_CHECK (result);
jclass klass = object->getClass();
if (klass->isArray())
{
jclass comp = klass->getComponentType();
jint base
= (jint) (_Jv_uintptr_t) _Jv_GetArrayElementFromElementType(NULL,
klass->getComponentType());
// FIXME: correct for primitive types?
jint compSize = comp->size();
__JArray *array = (__JArray *) object;
*result = base + array->length * compSize;
}
else
{
// Note that if OBJECT is a String then it may (if
// str->data==str) take more space. Do we care?
*result = klass->size();
}
return JVMTI_ERROR_NONE;
}
/* An event is enabled only if it has both an event handler
and it is enabled in the environment. */
static void
check_enabled_event (jvmtiEvent type)
{
bool *enabled;
int offset;
#define GET_OFFSET(Event) \
do \
{ \
enabled = &JVMTI::Event; \
offset = offsetof (jvmtiEventCallbacks, Event); \
} \
while (0)
switch (type)
{
case JVMTI_EVENT_VM_INIT:
GET_OFFSET (VMInit);
break;
case JVMTI_EVENT_VM_DEATH:
GET_OFFSET (VMDeath);
break;
case JVMTI_EVENT_THREAD_START:
GET_OFFSET (ThreadStart);
break;
case JVMTI_EVENT_THREAD_END:
GET_OFFSET (ThreadEnd);
break;
case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
GET_OFFSET (ClassFileLoadHook);
break;
case JVMTI_EVENT_CLASS_LOAD:
GET_OFFSET (ClassLoad);
break;
case JVMTI_EVENT_CLASS_PREPARE:
GET_OFFSET (ClassPrepare);
break;
case JVMTI_EVENT_VM_START:
GET_OFFSET (VMStart);
break;
case JVMTI_EVENT_EXCEPTION:
GET_OFFSET (Exception);
break;
case JVMTI_EVENT_EXCEPTION_CATCH:
GET_OFFSET (ExceptionCatch);
break;
case JVMTI_EVENT_SINGLE_STEP:
GET_OFFSET (SingleStep);
break;
case JVMTI_EVENT_FRAME_POP:
GET_OFFSET (FramePop);
break;
case JVMTI_EVENT_BREAKPOINT:
GET_OFFSET (Breakpoint);
break;
case JVMTI_EVENT_FIELD_ACCESS:
GET_OFFSET (FieldAccess);
break;
case JVMTI_EVENT_FIELD_MODIFICATION:
GET_OFFSET (FieldModification);
break;
case JVMTI_EVENT_METHOD_ENTRY:
GET_OFFSET (MethodEntry);
break;
case JVMTI_EVENT_METHOD_EXIT:
GET_OFFSET (MethodExit);
break;
case JVMTI_EVENT_NATIVE_METHOD_BIND:
GET_OFFSET (NativeMethodBind);
break;
case JVMTI_EVENT_COMPILED_METHOD_LOAD:
GET_OFFSET (CompiledMethodLoad);
break;
case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
GET_OFFSET (CompiledMethodUnload);
break;
case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
GET_OFFSET (DynamicCodeGenerated);
break;
case JVMTI_EVENT_DATA_DUMP_REQUEST:
GET_OFFSET (DataDumpRequest);
break;
case JVMTI_EVENT_MONITOR_WAIT:
GET_OFFSET (MonitorWait);
break;
case JVMTI_EVENT_MONITOR_WAITED:
GET_OFFSET (MonitorWaited);
break;
case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
GET_OFFSET (MonitorContendedEnter);
break;
case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
GET_OFFSET (MonitorContendedEntered);
break;
case JVMTI_EVENT_GARBAGE_COLLECTION_START:
GET_OFFSET (GarbageCollectionStart);
break;
case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
GET_OFFSET (GarbageCollectionFinish);
break;
case JVMTI_EVENT_OBJECT_FREE:
GET_OFFSET (ObjectFree);
break;
case JVMTI_EVENT_VM_OBJECT_ALLOC:
GET_OFFSET (VMObjectAlloc);
break;
default:
fprintf (stderr,
"libgcj: check_enabled_event for unknown JVMTI event (%d)\n",
(int) type);
return;
}
#undef GET_OFFSET
int index = EVENT_INDEX (type); // safe since caller checks this
if (_jvmtiEnvironments != NULL)
{
_envListLock->readLock ()->lock ();
struct jvmti_env_list *e;
FOREACH_ENVIRONMENT (e)
{
char *addr
= reinterpret_cast<char *> (&e->env->callbacks) + offset;
void **callback = reinterpret_cast<void **> (addr);
if (e->env->enabled[index] && *callback != NULL)
{
*enabled = true;
_envListLock->readLock ()->unlock ();
return;
}
}
_envListLock->readLock ()->unlock ();
}
*enabled = false;
}
static void
check_enabled_events ()
{
check_enabled_event (JVMTI_EVENT_VM_INIT);
check_enabled_event (JVMTI_EVENT_VM_DEATH);
check_enabled_event (JVMTI_EVENT_THREAD_START);
check_enabled_event (JVMTI_EVENT_THREAD_END);
check_enabled_event (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK);
check_enabled_event (JVMTI_EVENT_CLASS_LOAD);
check_enabled_event (JVMTI_EVENT_CLASS_PREPARE);
check_enabled_event (JVMTI_EVENT_VM_START);
check_enabled_event (JVMTI_EVENT_EXCEPTION);
check_enabled_event (JVMTI_EVENT_EXCEPTION_CATCH);
check_enabled_event (JVMTI_EVENT_SINGLE_STEP);
check_enabled_event (JVMTI_EVENT_FRAME_POP);
check_enabled_event (JVMTI_EVENT_BREAKPOINT);
check_enabled_event (JVMTI_EVENT_FIELD_ACCESS);
check_enabled_event (JVMTI_EVENT_FIELD_MODIFICATION);
check_enabled_event (JVMTI_EVENT_METHOD_ENTRY);
check_enabled_event (JVMTI_EVENT_METHOD_EXIT);
check_enabled_event (JVMTI_EVENT_NATIVE_METHOD_BIND);
check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_LOAD);
check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_UNLOAD);
check_enabled_event (JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
check_enabled_event (JVMTI_EVENT_DATA_DUMP_REQUEST);
check_enabled_event (JVMTI_EVENT_MONITOR_WAIT);
check_enabled_event (JVMTI_EVENT_MONITOR_WAITED);
check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTER);
check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED);
check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_START);
check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH);
check_enabled_event (JVMTI_EVENT_OBJECT_FREE);
check_enabled_event (JVMTI_EVENT_VM_OBJECT_ALLOC);
}
static jvmtiError JNICALL
_Jv_JVMTI_SetEventNotificationMode (jvmtiEnv *env, jvmtiEventMode mode,
jvmtiEvent type, jthread event_thread, ...)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
if (event_thread != NULL)
{
THREAD_CHECK_VALID (event_thread);
THREAD_CHECK_IS_ALIVE (event_thread);
}
bool enabled;
switch (mode)
{
case JVMTI_DISABLE:
enabled = false;
break;
case JVMTI_ENABLE:
enabled = true;
break;
default:
return JVMTI_ERROR_ILLEGAL_ARGUMENT;
}
switch (type)
{
case JVMTI_EVENT_VM_INIT:
case JVMTI_EVENT_VM_DEATH:
case JVMTI_EVENT_THREAD_START:
case JVMTI_EVENT_VM_START:
case JVMTI_EVENT_COMPILED_METHOD_LOAD:
case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
case JVMTI_EVENT_DATA_DUMP_REQUEST:
ILLEGAL_ARGUMENT (event_thread != NULL);
break;
case JVMTI_EVENT_THREAD_END:
case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
case JVMTI_EVENT_CLASS_LOAD:
case JVMTI_EVENT_CLASS_PREPARE:
case JVMTI_EVENT_EXCEPTION:
case JVMTI_EVENT_EXCEPTION_CATCH:
case JVMTI_EVENT_SINGLE_STEP:
case JVMTI_EVENT_FRAME_POP:
case JVMTI_EVENT_BREAKPOINT:
case JVMTI_EVENT_FIELD_ACCESS:
case JVMTI_EVENT_FIELD_MODIFICATION:
case JVMTI_EVENT_METHOD_ENTRY:
case JVMTI_EVENT_METHOD_EXIT:
case JVMTI_EVENT_NATIVE_METHOD_BIND:
case JVMTI_EVENT_MONITOR_WAIT:
case JVMTI_EVENT_MONITOR_WAITED:
case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
case JVMTI_EVENT_GARBAGE_COLLECTION_START:
case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
case JVMTI_EVENT_OBJECT_FREE:
case JVMTI_EVENT_VM_OBJECT_ALLOC:
break;
default:
return JVMTI_ERROR_INVALID_EVENT_TYPE;
}
env->thread[EVENT_INDEX(type)] = event_thread;
env->enabled[EVENT_INDEX(type)] = enabled;
check_enabled_event (type);
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_SetEventCallbacks (jvmtiEnv *env,
const jvmtiEventCallbacks *callbacks,
jint size_of_callbacks)
{
REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
ILLEGAL_ARGUMENT (size_of_callbacks < 0);
// Copy the list of callbacks into the environment
memcpy (&env->callbacks, callbacks, sizeof (jvmtiEventCallbacks));
/* Check which events are now enabeld (JVMTI makes no requirements
about the order in which SetEventCallbacks and SetEventNotifications
are called. So we must check all events here. */
check_enabled_events ();
return JVMTI_ERROR_NONE;
}
static jvmtiError JNICALL
_Jv_JVMTI_GetErrorName (MAYBE_UNUSED jvmtiEnv *env, jvmtiError error,
char **name_ptr)
{
NULL_CHECK (name_ptr);
const char *name;
switch (error)
{
case JVMTI_ERROR_NONE:
name = "none";
break;
case JVMTI_ERROR_NULL_POINTER:
name = "null pointer";
break;
case JVMTI_ERROR_OUT_OF_MEMORY:
name = "out of memory";
break;
case JVMTI_ERROR_ACCESS_DENIED:
name = "access denied";
break;
case JVMTI_ERROR_WRONG_PHASE:
name = "wrong phase";
break;
case JVMTI_ERROR_INTERNAL:
name = "internal error";
break;
case JVMTI_ERROR_UNATTACHED_THREAD:
name = "unattached thread";
break;
case JVMTI_ERROR_INVALID_ENVIRONMENT:
name = "invalid environment";
break;
case JVMTI_ERROR_INVALID_PRIORITY:
name = "invalid priority";
break;
case JVMTI_ERROR_THREAD_NOT_SUSPENDED:
name = "thread not suspended";
break;
case JVMTI_ERROR_THREAD_SUSPENDED:
name = "thread suspended";
break;
case JVMTI_ERROR_THREAD_NOT_ALIVE:
name = "thread not alive";
break;
case JVMTI_ERROR_CLASS_NOT_PREPARED:
name = "class not prepared";
break;
case JVMTI_ERROR_NO_MORE_FRAMES:
name = "no more frames";
break;
case JVMTI_ERROR_OPAQUE_FRAME:
name = "opaque frame";
break;
case JVMTI_ERROR_DUPLICATE:
name = "duplicate";
break;
case JVMTI_ERROR_NOT_FOUND:
name = "not found";
break;
case JVMTI_ERROR_NOT_MONITOR_OWNER:
name = "not monitor owner";
break;
case JVMTI_ERROR_INTERRUPT:
name = "interrupted";
break;
case JVMTI_ERROR_UNMODIFIABLE_CLASS:
name = "unmodifiable class";
break;
case JVMTI_ERROR_NOT_AVAILABLE:
name = "not available";
break;
case JVMTI_ERROR_ABSENT_INFORMATION:
name = "absent information";
break;
case JVMTI_ERROR_INVALID_EVENT_TYPE:
name = "invalid event type";
break;
case JVMTI_ERROR_NATIVE_METHOD:
name = "native method";
break;
case JVMTI_ERROR_INVALID_THREAD:
name = "invalid thread";
break;
case JVMTI_ERROR_INVALID_THREAD_GROUP:
name = "invalid thread group";
break;
case JVMTI_ERROR_INVALID_OBJECT:
name = "invalid object";
break;
case JVMTI_ERROR_INVALID_CLASS:
name = "invalid class";
break;
case JVMTI_ERROR_INVALID_METHODID:
name = "invalid method ID";
break;
case JVMTI_ERROR_INVALID_LOCATION:
name = "invalid location";
break;
case JVMTI_ERROR_INVALID_FIELDID:
name = "invalid field ID";
break;
case JVMTI_ERROR_TYPE_MISMATCH:
name = "type mismatch";
break;
case JVMTI_ERROR_INVALID_SLOT:
name = "invalid slot";
break;
case JVMTI_ERROR_INVALID_MONITOR:
name = "invalid monitor";
break;
case JVMTI_ERROR_INVALID_CLASS_FORMAT:
name = "invalid class format";
break;
case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION:
name = "circular class definition";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED:
name = "unsupported redefinition: method added";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED:
name = "unsupported redefinition: schema changed";
break;
case JVMTI_ERROR_INVALID_TYPESTATE:
name = "invalid type state";
break;
case JVMTI_ERROR_FAILS_VERIFICATION:
name = "fails verification";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED:
name = "unsupported redefinition: hierarchy changed";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED:
name = "unsupported redefinition: method deleted";
break;
case JVMTI_ERROR_UNSUPPORTED_VERSION:
name = "unsupported version";
break;
case JVMTI_ERROR_NAMES_DONT_MATCH:
name = "names do not match";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED:
name = "unsupported redefinition: class modifiers changed";
break;
case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED:
name = "unsupported redefinition: method modifiers changed";
break;
case JVMTI_ERROR_MUST_POSSESS_CAPABILITY:
name = "must possess capability";
break;
case JVMTI_ERROR_ILLEGAL_ARGUMENT:
name = "illegal argument";
break;
default:
return JVMTI_ERROR_ILLEGAL_ARGUMENT;
}
*name_ptr = (char *) _Jv_MallocUnchecked (strlen (name) + 1);
if (*name_ptr == NULL)
return JVMTI_ERROR_OUT_OF_MEMORY;
strcpy (*name_ptr, name);
return JVMTI_ERROR_NONE;
}
#define RESERVED NULL
#define UNIMPLEMENTED NULL
struct _Jv_jvmtiEnv _Jv_JVMTI_Interface =
{
RESERVED, // reserved1
_Jv_JVMTI_SetEventNotificationMode, // SetEventNotificationMode
RESERVED, // reserved3
_Jv_JVMTI_GetAllThreads, // GetAllThreads
_Jv_JVMTI_SuspendThread, // SuspendThread
_Jv_JVMTI_ResumeThread, // ResumeThread
UNIMPLEMENTED, // StopThread
_Jv_JVMTI_InterruptThread, // InterruptThread
UNIMPLEMENTED, // GetThreadInfo
UNIMPLEMENTED, // GetOwnedMonitorInfo
UNIMPLEMENTED, // GetCurrentContendedMonitor
UNIMPLEMENTED, // RunAgentThread
UNIMPLEMENTED, // GetTopThreadGroups
UNIMPLEMENTED, // GetThreadGroupInfo
UNIMPLEMENTED, // GetThreadGroupChildren
_Jv_JVMTI_GetFrameCount, // GetFrameCount
_Jv_JVMTI_GetThreadState, // GetThreadState
RESERVED, // reserved18
UNIMPLEMENTED, // GetFrameLocation
UNIMPLEMENTED, // NotifyPopFrame
_Jv_JVMTI_GetLocalObject, // GetLocalObject
_Jv_JVMTI_GetLocalInt, // GetLocalInt
_Jv_JVMTI_GetLocalLong, // GetLocalLong
_Jv_JVMTI_GetLocalFloat, // GetLocalFloat
_Jv_JVMTI_GetLocalDouble, // GetLocalDouble
_Jv_JVMTI_SetLocalObject, // SetLocalObject
_Jv_JVMTI_SetLocalInt, // SetLocalInt
_Jv_JVMTI_SetLocalLong, // SetLocalLong
_Jv_JVMTI_SetLocalFloat, // SetLocalFloat
_Jv_JVMTI_SetLocalDouble, // SetLocalDouble
_Jv_JVMTI_CreateRawMonitor, // CreateRawMonitor
_Jv_JVMTI_DestroyRawMonitor, // DestroyRawMonitor
_Jv_JVMTI_RawMonitorEnter, // RawMonitorEnter
_Jv_JVMTI_RawMonitorExit, // RawMonitorExit
_Jv_JVMTI_RawMonitorWait, // RawMonitorWait
_Jv_JVMTI_RawMonitorNotify, // RawMonitorNotify
_Jv_JVMTI_RawMonitorNotifyAll, // RawMonitorNotifyAll
_Jv_JVMTI_SetBreakpoint, // SetBreakpoint
_Jv_JVMTI_ClearBreakpoint, // ClearBreakpoint
RESERVED, // reserved40
UNIMPLEMENTED, // SetFieldAccessWatch
UNIMPLEMENTED, // ClearFieldAccessWatch
UNIMPLEMENTED, // SetFieldModificationWatch
UNIMPLEMENTED, // ClearFieldModificationWatch
RESERVED, // reserved45
_Jv_JVMTI_Allocate, // Allocate
_Jv_JVMTI_Deallocate, // Deallocate
UNIMPLEMENTED, // GetClassSignature
_Jv_JVMTI_GetClassStatus, // GetClassStatus
UNIMPLEMENTED, // GetSourceFileName
_Jv_JVMTI_GetClassModifiers, // GetClassModifiers
_Jv_JVMTI_GetClassMethods, // GetClassMethods
UNIMPLEMENTED, // GetClassFields
UNIMPLEMENTED, // GetImplementedInterfaces
_Jv_JVMTI_IsInterface, // IsInterface
_Jv_JVMTI_IsArrayClass, // IsArrayClass
_Jv_JVMTI_GetClassLoader, // GetClassLoader
_Jv_JVMTI_GetObjectHashCode, // GetObjectHashCode
UNIMPLEMENTED, // GetObjectMonitorUsage
UNIMPLEMENTED, // GetFieldName
UNIMPLEMENTED, // GetFieldDeclaringClass
_Jv_JVMTI_GetFieldModifiers, // GetFieldModifiers
_Jv_JVMTI_IsFieldSynthetic, // IsFieldSynthetic
_Jv_JVMTI_GetMethodName, // GetMethodName
_Jv_JVMTI_GetMethodDeclaringClass, // GetMethodDeclaringClass
_Jv_JVMTI_GetMethodModifiers, // GetMethodModifers
RESERVED, // reserved67
_Jv_JVMTI_GetMaxLocals, // GetMaxLocals
_Jv_JVMTI_GetArgumentsSize, // GetArgumentsSize
_Jv_JVMTI_GetLineNumberTable, // GetLineNumberTable
UNIMPLEMENTED, // GetMethodLocation
_Jv_JVMTI_GetLocalVariableTable, // GetLocalVariableTable
RESERVED, // reserved73
RESERVED, // reserved74
UNIMPLEMENTED, // GetBytecodes
_Jv_JVMTI_IsMethodNative, // IsMethodNative
_Jv_JVMTI_IsMethodSynthetic, // IsMethodSynthetic
UNIMPLEMENTED, // GetLoadedClasses
_Jv_JVMTI_GetClassLoaderClasses, // GetClassLoaderClasses
UNIMPLEMENTED, // PopFrame
RESERVED, // reserved81
RESERVED, // reserved82
RESERVED, // reserved83
RESERVED, // reserved84
RESERVED, // reserved85
RESERVED, // reserved86
UNIMPLEMENTED, // RedefineClasses
UNIMPLEMENTED, // GetVersionNumber
UNIMPLEMENTED, // GetCapabilities
UNIMPLEMENTED, // GetSourceDebugExtension
UNIMPLEMENTED, // IsMethodObsolete
UNIMPLEMENTED, // SuspendThreadList
UNIMPLEMENTED, // ResumeThreadList
RESERVED, // reserved94
RESERVED, // reserved95
RESERVED, // reserved96
RESERVED, // reserved97
RESERVED, // reserved98
RESERVED, // reserved99
UNIMPLEMENTED, // GetAllStackTraces
UNIMPLEMENTED, // GetThreadListStackTraces
UNIMPLEMENTED, // GetThreadLocalStorage
UNIMPLEMENTED, // SetThreadLocalStorage
_Jv_JVMTI_GetStackTrace, // GetStackTrace
RESERVED, // reserved105
UNIMPLEMENTED, // GetTag
UNIMPLEMENTED, // SetTag
_Jv_JVMTI_ForceGarbageCollection, // ForceGarbageCollection
UNIMPLEMENTED, // IterateOverObjectsReachable
UNIMPLEMENTED, // IterateOverReachableObjects
UNIMPLEMENTED, // IterateOverHeap
UNIMPLEMENTED, // IterateOverInstanceOfClass
RESERVED, // reserved113
UNIMPLEMENTED, // GetObjectsWithTags
RESERVED, // reserved115
RESERVED, // reserved116
RESERVED, // reserved117
RESERVED, // reserved118
RESERVED, // reserved119
_Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable
_Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable
_Jv_JVMTI_SetEventCallbacks, // SetEventCallbacks
UNIMPLEMENTED, // GenerateEvents
UNIMPLEMENTED, // GetExtensionFunctions
UNIMPLEMENTED, // GetExtensionEvents
UNIMPLEMENTED, // SetExtensionEventCallback
_Jv_JVMTI_DisposeEnvironment, // DisposeEnvironment
_Jv_JVMTI_GetErrorName, // GetErrorName
UNIMPLEMENTED, // GetJLocationFormat
UNIMPLEMENTED, // GetSystemProperties
_Jv_JVMTI_GetSystemProperty, // GetSystemProperty
_Jv_JVMTI_SetSystemProperty, // SetSystemProperty
UNIMPLEMENTED, // GetPhase
UNIMPLEMENTED, // GetCurrentThreadCpuTimerInfo
UNIMPLEMENTED, // GetCurrentThreadCpuTime
UNIMPLEMENTED, // GetThreadCpuTimerInfo
UNIMPLEMENTED, // GetThreadCpuTime
UNIMPLEMENTED, // GetTimerInfo
_Jv_JVMTI_GetTime, // GetTime
UNIMPLEMENTED, // GetPotentialCapabilities
RESERVED, // reserved141
UNIMPLEMENTED, // AddCapabilities
UNIMPLEMENTED, // RelinquishCapabilities
_Jv_JVMTI_GetAvailableProcessors, // GetAvailableProcessors
RESERVED, // reserved145
RESERVED, // reserved146
UNIMPLEMENTED, // GetEnvironmentLocalStorage
UNIMPLEMENTED, // SetEnvironmentLocalStorage
_Jv_JVMTI_AddToBootstrapClassLoaderSearch, // AddToBootstrapClassLoaderSearch
_Jv_JVMTI_SetVerboseFlag, // SetVerboseFlag
RESERVED, // reserved151
RESERVED, // reserved152
RESERVED, // reserved153
_Jv_JVMTI_GetObjectSize // GetObjectSize
};
_Jv_JVMTIEnv *
_Jv_GetJVMTIEnv (void)
{
_Jv_JVMTIEnv *env
= (_Jv_JVMTIEnv *) _Jv_MallocUnchecked (sizeof (_Jv_JVMTIEnv));
memset (env, 0, sizeof (_Jv_JVMTIEnv));
env->p = &_Jv_JVMTI_Interface;
struct jvmti_env_list *element
= (struct jvmti_env_list *) _Jv_MallocUnchecked (sizeof (struct jvmti_env_list));
element->env = env;
element->next = NULL;
_envListLock->writeLock ()->lock ();
if (_jvmtiEnvironments == NULL)
_jvmtiEnvironments = element;
else
{
struct jvmti_env_list *e;
for (e = _jvmtiEnvironments; e->next != NULL; e = e->next)
;
e->next = element;
}
_envListLock->writeLock ()->unlock ();
/* Mark JVMTI active. This is used to force the interpreter
to use either debugging or non-debugging code. Once JVMTI
has been enabled, the non-debug interpreter cannot be used. */
JVMTI::enabled = true;
return env;
}
void
_Jv_JVMTI_Init ()
{
_jvmtiEnvironments = NULL;
_envListLock
= new java::util::concurrent::locks::ReentrantReadWriteLock ();
// No environments, so this should set all JVMTI:: members to false
check_enabled_events ();
}
static void
post_event (jvmtiEnv *env, jvmtiEvent type, jthread event_thread, va_list args)
{
#define ARG(Type,Name) Type Name = (Type) va_arg (args, Type)
#define GET_BOOLEAN_ARG(Name) \
ARG (int, b); \
jboolean Name = (b == 0) ? false : true
#define GET_CHAR_ARG(Name) \
ARG (int, c); \
char Name = static_cast<char> (c)
switch (type)
{
case JVMTI_EVENT_VM_INIT:
if (env->callbacks.VMInit != NULL)
{
ARG (JNIEnv *, jni_env);
env->callbacks.VMInit (env, jni_env, event_thread);
}
break;
case JVMTI_EVENT_VM_DEATH:
if (env->callbacks.VMDeath != NULL)
{
ARG (JNIEnv *, jni_env);
env->callbacks.VMDeath (env, jni_env);
}
break;
case JVMTI_EVENT_THREAD_START:
if (env->callbacks.ThreadStart != NULL)
{
ARG (JNIEnv *, jni_env);
env->callbacks.ThreadStart (env, jni_env, event_thread);
}
break;
case JVMTI_EVENT_THREAD_END:
if (env->callbacks.ThreadEnd != NULL)
{
ARG (JNIEnv *, jni_env);
env->callbacks.ThreadEnd (env, jni_env, event_thread);
}
break;
case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
if (env->callbacks.ClassFileLoadHook != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jclass, class_being_redefined);
ARG (jobject, loader);
ARG (const char *, name);
ARG (jobject, protection_domain);
ARG (jint, class_data_len);
ARG (const unsigned char *, class_data);
ARG (jint *, new_class_data_len);
ARG (unsigned char **, new_class_data);
env->callbacks.ClassFileLoadHook (env, jni_env,
class_being_redefined, loader,
name, protection_domain,
class_data_len, class_data,
new_class_data_len,
new_class_data);
}
break;
case JVMTI_EVENT_CLASS_LOAD:
if (env->callbacks.ClassLoad != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jclass, klass);
env->callbacks.ClassLoad (env, jni_env, event_thread, klass);
}
break;
case JVMTI_EVENT_CLASS_PREPARE:
if (env->callbacks.ClassPrepare != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jclass, klass);
env->callbacks.ClassPrepare (env, jni_env, event_thread, klass);
}
break;
case JVMTI_EVENT_VM_START:
if (env->callbacks.VMStart != NULL)
{
ARG (JNIEnv *, jni_env);
env->callbacks.VMStart (env, jni_env);
}
break;
case JVMTI_EVENT_EXCEPTION:
if (env->callbacks.Exception != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
ARG (jobject, exception);
ARG (jmethodID, catch_method);
ARG (jlocation, catch_location);
env->callbacks.Exception (env, jni_env, event_thread, method,
location, exception, catch_method,
catch_location);
}
break;
case JVMTI_EVENT_EXCEPTION_CATCH:
if (env->callbacks.ExceptionCatch != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
ARG (jobject, exception);
env->callbacks.ExceptionCatch (env, jni_env, event_thread, method,
location, exception);
}
break;
case JVMTI_EVENT_SINGLE_STEP:
if (env->callbacks.SingleStep != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
env->callbacks.SingleStep (env, jni_env, event_thread, method,
location);
}
break;
case JVMTI_EVENT_FRAME_POP:
if (env->callbacks.FramePop != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
GET_BOOLEAN_ARG (was_popped_by_exception);
env->callbacks.FramePop (env, jni_env, event_thread, method,
was_popped_by_exception);
}
break;
case JVMTI_EVENT_BREAKPOINT:
if (env->callbacks.Breakpoint != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
env->callbacks.Breakpoint (env, jni_env, event_thread, method,
location);
}
break;
case JVMTI_EVENT_FIELD_ACCESS:
if (env->callbacks.FieldAccess != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
ARG (jclass, field_class);
ARG (jobject, object);
ARG (jfieldID, field);
env->callbacks.FieldAccess (env, jni_env, event_thread, method,
location, field_class, object, field);
}
break;
case JVMTI_EVENT_FIELD_MODIFICATION:
if (env->callbacks.FieldModification != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (jlocation, location);
ARG (jclass, field_class);
ARG (jobject, object);
ARG (jfieldID, field);
GET_CHAR_ARG (signature_type);
ARG (jvalue, new_value);
env->callbacks.FieldModification (env, jni_env, event_thread, method,
location, field_class, object,
field, signature_type, new_value);
}
break;
case JVMTI_EVENT_METHOD_ENTRY:
if (env->callbacks.MethodEntry != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
env->callbacks.MethodEntry (env, jni_env, event_thread, method);
}
break;
case JVMTI_EVENT_METHOD_EXIT:
if (env->callbacks.MethodExit != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
GET_BOOLEAN_ARG (was_popped_by_exception);
ARG (jvalue, return_value);
env->callbacks.MethodExit (env, jni_env, event_thread, method,
was_popped_by_exception, return_value);
}
break;
case JVMTI_EVENT_NATIVE_METHOD_BIND:
if (env->callbacks.NativeMethodBind != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jmethodID, method);
ARG (void *, address);
ARG (void **, new_address_ptr);
env->callbacks.NativeMethodBind (env, jni_env, event_thread, method,
address, new_address_ptr);
}
break;
case JVMTI_EVENT_COMPILED_METHOD_LOAD:
if (env->callbacks.CompiledMethodLoad != NULL)
{
ARG (jmethodID, method);
ARG (jint, code_size);
ARG (const void *, code_addr);
ARG (jint, map_length);
ARG (const jvmtiAddrLocationMap *, map);
ARG (const void *, compile_info);
env->callbacks.CompiledMethodLoad (env, method, code_size, code_addr,
map_length, map, compile_info);
}
break;
case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
if (env->callbacks.CompiledMethodUnload != NULL)
{
ARG (jmethodID, method);
ARG (const void *, code_addr);
env->callbacks.CompiledMethodUnload (env, method, code_addr);
}
break;
case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
if (env->callbacks.DynamicCodeGenerated != NULL)
{
ARG (const char *, name);
ARG (const void *, address);
ARG (jint, length);
env->callbacks.DynamicCodeGenerated (env, name, address, length);
}
break;
case JVMTI_EVENT_DATA_DUMP_REQUEST:
if (env->callbacks.DataDumpRequest != NULL)
{
env->callbacks.DataDumpRequest (env);
}
break;
case JVMTI_EVENT_MONITOR_WAIT:
if (env->callbacks.MonitorWait != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jobject, object);
ARG (jlong, timeout);
env->callbacks.MonitorWait (env, jni_env, event_thread, object,
timeout);
}
break;
case JVMTI_EVENT_MONITOR_WAITED:
if (env->callbacks.MonitorWaited != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jobject, object);
GET_BOOLEAN_ARG (timed_out);
env->callbacks.MonitorWaited (env, jni_env, event_thread, object,
timed_out);
}
break;
case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
if (env->callbacks.MonitorContendedEnter != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jobject, object);
env->callbacks.MonitorContendedEnter (env, jni_env, event_thread,
object);
}
break;
case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
if (env->callbacks.MonitorContendedEntered != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jobject, object);
env->callbacks.MonitorContendedEntered (env, jni_env, event_thread,
object);
}
break;
case JVMTI_EVENT_GARBAGE_COLLECTION_START:
if (env->callbacks.GarbageCollectionStart != NULL)
{
env->callbacks.GarbageCollectionStart (env);
}
break;
case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
if (env->callbacks.GarbageCollectionFinish != NULL)
{
env->callbacks.GarbageCollectionFinish (env);
}
break;
case JVMTI_EVENT_OBJECT_FREE:
if (env->callbacks.ObjectFree != NULL)
{
ARG (jlong, tag);
env->callbacks.ObjectFree (env, tag);
}
break;
case JVMTI_EVENT_VM_OBJECT_ALLOC:
if (env->callbacks.VMObjectAlloc != NULL)
{
ARG (JNIEnv *, jni_env);
ARG (jobject, object);
ARG (jclass, object_class);
ARG (jlong, size);
env->callbacks.VMObjectAlloc (env, jni_env, event_thread,
object, object_class, size);
}
break;
default:
fprintf (stderr, "libgcj: post of unknown JVMTI event (%d)\n",
(int) type);
break;
}
va_end (args);
#undef ARG
#undef GET_BOOLEAN_ARG
#undef GET_CHAR_ARG
}
/* Post an event to requesting JVMTI environments
*
* This function should not be called without consulting the
* JVMTI_REQUESTED_EVENT macro first (for speed). It does no real
* harm (other than kill speed), since this function will still
* only send the event if it was properly requested by an environment.
*/
void
_Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...)
{
va_list args;
va_start (args, event_thread);
_envListLock->readLock ()->lock ();
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);
}
}
_envListLock->readLock ()->unlock ();
va_end (args);
}
Reference in New Issue View Git Blame Copy Permalink