OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [jvmti.cc] - Blame information for rev 762

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 753 jeremybenn
// jvmti.cc - JVMTI implementation
2
 
3
/* Copyright (C) 2006, 2007, 2010 Free Software Foundation
4
 
5
   This file is part of libgcj.
6
 
7
This software is copyrighted work licensed under the terms of the
8
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9
details.  */
10
 
11
#include <config.h>
12
#include <platform.h>
13
 
14
#include <jvm.h>
15
#include <java-threads.h>
16
#include <java-gc.h>
17
#include <java-interp.h>
18
#include <jvmti.h>
19
#include "jvmti-int.h"
20
 
21
#include <gcj/method.h>
22
 
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>
27
 
28
#include <java/lang/Class.h>
29
#include <java/lang/ClassLoader.h>
30
#include <java/lang/OutOfMemoryError.h>
31
#include <java/lang/Thread.h>
32
#include <java/lang/ThreadGroup.h>
33
#include <java/lang/Thread$State.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/util/concurrent/locks/Lock.h>
41
#include <java/util/concurrent/locks/ReentrantReadWriteLock.h>
42
#include <java/net/URL.h>
43
 
44
static void check_enabled_events (void);
45
static void check_enabled_event (jvmtiEvent);
46
 
47
namespace JVMTI
48
{
49
  // Is JVMTI enabled? (i.e., any jvmtiEnv created?)
50
  bool enabled;
51
 
52
  // Event notifications
53
  bool VMInit = false;
54
  bool VMDeath = false;
55
  bool ThreadStart = false;
56
  bool ThreadEnd = false;
57
  bool ClassFileLoadHook = false;
58
  bool ClassLoad = false;
59
  bool ClassPrepare = false;
60
  bool VMStart = false;
61
  bool Exception = false;
62
  bool ExceptionCatch = false;
63
  bool SingleStep = false;
64
  bool FramePop = false;
65
  bool Breakpoint = false;
66
  bool FieldAccess = false;
67
  bool FieldModification = false;
68
  bool MethodEntry = false;
69
  bool MethodExit = false;
70
  bool NativeMethodBind = false;
71
  bool CompiledMethodLoad = false;
72
  bool CompiledMethodUnload = false;
73
  bool DynamicCodeGenerated = false;
74
  bool DataDumpRequest = false;
75
  bool reserved72 = false;
76
  bool MonitorWait = false;
77
  bool MonitorWaited = false;
78
  bool MonitorContendedEnter = false;
79
  bool MonitorContendedEntered = false;
80
  bool reserved77 = false;
81
  bool reserved78 = false;
82
  bool reserved79 = false;
83
  bool reserved80 = false;
84
  bool GarbageCollectionStart = false;
85
  bool GarbageCollectionFinish = false;
86
  bool ObjectFree = false;
87
  bool VMObjectAlloc = false;
88
};
89
 
90
extern struct JNINativeInterface _Jv_JNIFunctions;
91
 
92
struct _Jv_rawMonitorID
93
{
94
  _Jv_Mutex_t mutex;
95
  _Jv_ConditionVariable_t condition;
96
};
97
 
98
/* A simple linked list of all JVMTI environments. Since
99
   events must be delivered to environments in the order
100
   in which the environments were created, new environments
101
   are added to the end of the list. */
102
struct jvmti_env_list
103
{
104
  jvmtiEnv *env;
105
  struct jvmti_env_list *next;
106
};
107
static struct jvmti_env_list *_jvmtiEnvironments = NULL;
108
static java::util::concurrent::locks::
109
ReentrantReadWriteLock *_envListLock = NULL;
110
#define FOREACH_ENVIRONMENT(Ele) \
111
  for (Ele = _jvmtiEnvironments; Ele != NULL; Ele = Ele->next)
112
 
113
// Some commonly-used checks
114
 
115
#define THREAD_DEFAULT_TO_CURRENT(Ajthread)             \
116
  do                                                    \
117
    {                                                   \
118
      if (Ajthread == NULL)                             \
119
        Ajthread = java::lang::Thread::currentThread ();        \
120
    }                                                   \
121
  while (0)
122
 
123
#define THREAD_CHECK_VALID(Athread)                                     \
124
  do                                                                    \
125
    {                                                                   \
126
      if (!java::lang::Thread::class$.isAssignableFrom (&(Athread->class$))) \
127
        return JVMTI_ERROR_INVALID_THREAD;                              \
128
    }                                                                   \
129
  while (0)
130
 
131
#define THREAD_CHECK_IS_ALIVE(Athread)       \
132
  do                                         \
133
    {                                        \
134
      if (!Athread->isAlive ())              \
135
        return JVMTI_ERROR_THREAD_NOT_ALIVE; \
136
    }                                        \
137
  while (0)
138
 
139
// FIXME: if current phase is not set in Phases,
140
// return JVMTI_ERROR_WRONG_PHASE
141
#define REQUIRE_PHASE(Env, Phases)
142
 
143
#define NULL_CHECK(Ptr)                         \
144
  do                                            \
145
    {                                           \
146
      if (Ptr == NULL)                          \
147
        return JVMTI_ERROR_NULL_POINTER;        \
148
    }                                           \
149
  while (0)
150
 
151
#define ILLEGAL_ARGUMENT(Cond)                  \
152
  do                                            \
153
    {                                           \
154
      if ((Cond))                               \
155
        return JVMTI_ERROR_ILLEGAL_ARGUMENT;    \
156
    }                                           \
157
  while (0)
158
 
159
#define CHECK_FOR_NATIVE_METHOD(AjmethodID)     \
160
  do                                    \
161
    {                                   \
162
      jboolean is_native;               \
163
      jvmtiError jerr = env->IsMethodNative (AjmethodID, &is_native);   \
164
      if (jerr != JVMTI_ERROR_NONE)                                     \
165
        return jerr;                                                    \
166
      if (is_native)                                                    \
167
        return JVMTI_ERROR_NATIVE_METHOD;                               \
168
    }                                                                   \
169
  while (0)
170
 
171
static jvmtiError JNICALL
172
_Jv_JVMTI_SuspendThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
173
{
174
  using namespace java::lang;
175
 
176
  THREAD_DEFAULT_TO_CURRENT (thread);
177
  THREAD_CHECK_VALID (thread);
178
  THREAD_CHECK_IS_ALIVE (thread);
179
 
180
  _Jv_Thread_t *data = _Jv_ThreadGetData (thread);
181
  _Jv_SuspendThread (data);
182
  return JVMTI_ERROR_NONE;
183
}
184
 
185
static jvmtiError JNICALL
186
_Jv_JVMTI_ResumeThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
187
{
188
  using namespace java::lang;
189
 
190
  THREAD_DEFAULT_TO_CURRENT (thread);
191
  THREAD_CHECK_VALID (thread);
192
  THREAD_CHECK_IS_ALIVE (thread);
193
 
194
  _Jv_Thread_t *data = _Jv_ThreadGetData (thread);
195
  _Jv_ResumeThread (data);
196
  return JVMTI_ERROR_NONE;
197
}
198
 
199
static jvmtiError JNICALL
200
_Jv_JVMTI_InterruptThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
201
{
202
  using namespace java::lang;
203
 
204
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
205
  // FIXME: capability handling?  'can_signal_thread'
206
  if (thread == NULL)
207
    return JVMTI_ERROR_INVALID_THREAD;
208
 
209
  THREAD_CHECK_VALID (thread);
210
  THREAD_CHECK_IS_ALIVE (thread);
211
  thread->interrupt();
212
  return JVMTI_ERROR_NONE;
213
}
214
 
215
// This method performs the common tasks to get and set variables of all types.
216
// It is called by the _Jv_JVMTI_Get/SetLocalInt/Object/.... methods.
217
static jvmtiError
218
getLocalFrame (jvmtiEnv *env, jthread thread, jint depth, jint slot, char type,
219
               _Jv_InterpFrame **iframe)
220
{
221
  using namespace java::lang;
222
 
223
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
224
 
225
  ILLEGAL_ARGUMENT (depth < 0);
226
 
227
  THREAD_DEFAULT_TO_CURRENT (thread);
228
  THREAD_CHECK_VALID (thread);
229
  THREAD_CHECK_IS_ALIVE (thread);
230
 
231
  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
232
 
233
  for (int i = 0; i < depth; i++)
234
    {
235
      frame = frame->next;
236
 
237
      if (frame == NULL)
238
        return JVMTI_ERROR_NO_MORE_FRAMES;
239
    }
240
 
241
  if (frame->frame_type == frame_native)
242
    return JVMTI_ERROR_OPAQUE_FRAME;
243
 
244
  jint max_locals;
245
  jvmtiError jerr = env->GetMaxLocals (reinterpret_cast<jmethodID>
246
                                         (frame->self->get_method ()),
247
                                       &max_locals);
248
  if (jerr != JVMTI_ERROR_NONE)
249
    return jerr;
250
 
251
  _Jv_InterpFrame *tmp_iframe = reinterpret_cast<_Jv_InterpFrame *> (frame);
252
 
253
  // The second slot taken up by a long type is marked as type 'x' meaning it
254
  // is not valid for access since it holds only the 4 low bytes of the value.
255
  if (tmp_iframe->locals_type[slot] == 'x')
256
    return JVMTI_ERROR_INVALID_SLOT;
257
 
258
  if (tmp_iframe->locals_type[slot] != type)
259
    return JVMTI_ERROR_TYPE_MISMATCH;
260
 
261
  // Check for invalid slots, if the type is a long type, we must check that
262
  // the next slot is valid as well.
263
  if (slot < 0 || slot >= max_locals
264
      || ((type == 'l' || type == 'd') && slot + 1 >= max_locals))
265
    return JVMTI_ERROR_INVALID_SLOT;
266
 
267
  *iframe = tmp_iframe;
268
 
269
  return JVMTI_ERROR_NONE;
270
}
271
 
272
static jvmtiError JNICALL
273
_Jv_JVMTI_GetLocalObject (jvmtiEnv *env, jthread thread, jint depth, jint slot,
274
                          jobject *value)
275
{
276
  NULL_CHECK (value);
277
 
278
  _Jv_InterpFrame *frame;
279
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'o', &frame);
280
 
281
  if (jerr != JVMTI_ERROR_NONE)
282
    return jerr;
283
 
284
  *value = frame->locals[slot].o;
285
 
286
  return JVMTI_ERROR_NONE;
287
}
288
 
289
static jvmtiError JNICALL
290
_Jv_JVMTI_SetLocalObject (jvmtiEnv *env, jthread thread, jint depth, jint slot,
291
                          jobject value)
292
{
293
  _Jv_InterpFrame *frame;
294
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'o', &frame);
295
 
296
  if (jerr != JVMTI_ERROR_NONE)
297
    return jerr;
298
 
299
  frame->locals[slot].o = value;
300
 
301
  return JVMTI_ERROR_NONE;
302
}
303
 
304
static jvmtiError JNICALL
305
_Jv_JVMTI_GetLocalInt (jvmtiEnv *env, jthread thread, jint depth, jint slot,
306
                       jint *value)
307
{
308
  NULL_CHECK (value);
309
 
310
  _Jv_InterpFrame *frame;
311
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'i', &frame);
312
 
313
  if (jerr != JVMTI_ERROR_NONE)
314
    return jerr;
315
 
316
  *value = frame->locals[slot].i;
317
 
318
  return JVMTI_ERROR_NONE;
319
}
320
 
321
static jvmtiError JNICALL
322
_Jv_JVMTI_SetLocalInt (jvmtiEnv *env, jthread thread, jint depth, jint slot,
323
                       jint value)
324
{
325
  _Jv_InterpFrame *frame;
326
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'i', &frame);
327
 
328
  if (jerr != JVMTI_ERROR_NONE)
329
    return jerr;
330
 
331
  frame->locals[slot].i = value;
332
 
333
  return JVMTI_ERROR_NONE;
334
}
335
 
336
static jvmtiError JNICALL
337
_Jv_JVMTI_GetLocalLong (jvmtiEnv *env, jthread thread, jint depth, jint slot,
338
                        jlong *value)
339
{
340
  NULL_CHECK (value);
341
 
342
  _Jv_InterpFrame *frame;
343
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'l', &frame);
344
 
345
  if (jerr != JVMTI_ERROR_NONE)
346
    return jerr;
347
 
348
#if SIZEOF_VOID_P==8
349
  *value = frame->locals[slot].l;
350
#else
351
  _Jv_word2 val;
352
  val.ia[0] = frame->locals[slot].ia[0];
353
  val.ia[1] = frame->locals[slot + 1].ia[0];
354
  *value = val.l;
355
#endif
356
 
357
  return JVMTI_ERROR_NONE;
358
}
359
 
360
static jvmtiError JNICALL
361
_Jv_JVMTI_SetLocalLong (jvmtiEnv *env, jthread thread, jint depth, jint slot,
362
                        jlong value)
363
{
364
  _Jv_InterpFrame *frame;
365
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'l', &frame);
366
 
367
  if (jerr != JVMTI_ERROR_NONE)
368
    return jerr;
369
 
370
#if SIZEOF_VOID_P==8
371
  frame->locals[slot].l = value;
372
#else
373
  _Jv_word2 val;
374
        val.l = value;
375
        frame->locals[slot].ia[0] = val.ia[0];
376
        frame->locals[slot + 1].ia[0] = val.ia[1];
377
#endif
378
 
379
  return JVMTI_ERROR_NONE;
380
}
381
 
382
 
383
static jvmtiError JNICALL
384
_Jv_JVMTI_GetLocalFloat (jvmtiEnv *env, jthread thread, jint depth, jint slot,
385
                         jfloat *value)
386
{
387
  NULL_CHECK (value);
388
 
389
  _Jv_InterpFrame *frame;
390
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'f', &frame);
391
 
392
  if (jerr != JVMTI_ERROR_NONE)
393
    return jerr;
394
 
395
  *value = frame->locals[slot].f;
396
 
397
  return JVMTI_ERROR_NONE;
398
}
399
 
400
static jvmtiError JNICALL
401
_Jv_JVMTI_SetLocalFloat (jvmtiEnv *env, jthread thread, jint depth, jint slot,
402
                         jfloat value)
403
{
404
  _Jv_InterpFrame *frame;
405
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'f', &frame);
406
 
407
  if (jerr != JVMTI_ERROR_NONE)
408
    return jerr;
409
 
410
  frame->locals[slot].f = value;
411
 
412
  return JVMTI_ERROR_NONE;
413
}
414
 
415
 
416
static jvmtiError JNICALL
417
_Jv_JVMTI_GetLocalDouble (jvmtiEnv *env, jthread thread, jint depth, jint slot,
418
                          jdouble *value)
419
{
420
  NULL_CHECK (value);
421
 
422
  _Jv_InterpFrame *frame;
423
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'd', &frame);
424
 
425
  if (jerr != JVMTI_ERROR_NONE)
426
    return jerr;
427
 
428
#if SIZEOF_VOID_P==8
429
  *value = frame->locals[slot].d;
430
#else
431
  _Jv_word2 val;
432
  val.ia[0] = frame->locals[slot].ia[0];
433
  val.ia[1] = frame->locals[slot + 1].ia[0];
434
  *value = val.d;
435
#endif
436
 
437
  return JVMTI_ERROR_NONE;
438
}
439
 
440
static jvmtiError JNICALL
441
_Jv_JVMTI_SetLocalDouble (jvmtiEnv *env, jthread thread, jint depth, jint slot,
442
                          jdouble value)
443
{
444
  _Jv_InterpFrame *frame;
445
  jvmtiError jerr = getLocalFrame (env, thread, depth, slot, 'd', &frame);
446
 
447
  if (jerr != JVMTI_ERROR_NONE)
448
    return jerr;
449
 
450
#if SIZEOF_VOID_P==8
451
  frame->locals[slot].d = value;
452
#else
453
  _Jv_word2 val;
454
  val.d = value;
455
  frame->locals[slot].ia[0] = val.ia[0];
456
  frame->locals[slot + 1].ia[0] = val.ia[1];
457
#endif
458
 
459
  return JVMTI_ERROR_NONE;
460
}
461
 
462
static jvmtiError JNICALL
463
_Jv_JVMTI_GetAllThreads(MAYBE_UNUSED jvmtiEnv *env, jint *thread_cnt,
464
                        jthread **threads)
465
{
466
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
467
  NULL_CHECK (thread_cnt);
468
  NULL_CHECK (threads);
469
 
470
  using namespace java::lang;
471
 
472
  ThreadGroup *root_grp = ThreadGroup::root;
473
  jint estimate = root_grp->activeCount ();
474
 
475
  JArray<Thread *> *thr_arr;
476
 
477
  // Allocate some extra space since threads can be created between calls
478
  try
479
    {
480
      thr_arr = reinterpret_cast<JArray<Thread *> *> (JvNewObjectArray
481
                                                      ((estimate * 2),
482
                                                       &Thread::class$, NULL));
483
    }
484
  catch (java::lang::OutOfMemoryError *err)
485
    {
486
      return JVMTI_ERROR_OUT_OF_MEMORY;
487
    }
488
 
489
  *thread_cnt = root_grp->enumerate (thr_arr);
490
 
491
  jvmtiError jerr = env->Allocate ((jlong) ((*thread_cnt) * sizeof (jthread)),
492
                                   (unsigned char **) threads);
493
 
494
  if (jerr != JVMTI_ERROR_NONE)
495
    return jerr;
496
 
497
  // Transfer the threads to the result array
498
  jthread *tmp_arr = reinterpret_cast<jthread *> (elements (thr_arr));
499
 
500
  memcpy ((*threads), tmp_arr, (*thread_cnt));
501
 
502
  return JVMTI_ERROR_NONE;
503
}
504
 
505
static jvmtiError JNICALL
506
_Jv_JVMTI_GetFrameCount (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
507
                         jint *frame_count)
508
{
509
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
510
 
511
  NULL_CHECK (frame_count);
512
 
513
  using namespace java::lang;
514
 
515
  THREAD_DEFAULT_TO_CURRENT (thread);
516
  THREAD_CHECK_VALID (thread);
517
  THREAD_CHECK_IS_ALIVE (thread);
518
 
519
  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
520
  (*frame_count) = frame->depth ();
521
  return JVMTI_ERROR_NONE;
522
}
523
 
524
static jvmtiError JNICALL
525
_Jv_JVMTI_GetThreadState (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
526
                          jint *thread_state_ptr)
527
{
528
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
529
 
530
  THREAD_DEFAULT_TO_CURRENT (thread);
531
  THREAD_CHECK_VALID (thread);
532
  NULL_CHECK (thread_state_ptr);
533
 
534
  jint state = 0;
535
  if (thread->isAlive ())
536
    {
537
      state |= JVMTI_THREAD_STATE_ALIVE;
538
 
539
      _Jv_Thread_t *data = _Jv_ThreadGetData (thread);
540
      if (_Jv_IsThreadSuspended (data))
541
        state |= JVMTI_THREAD_STATE_SUSPENDED;
542
 
543
      if (thread->isInterrupted ())
544
        state |= JVMTI_THREAD_STATE_INTERRUPTED;
545
 
546
      _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
547
      if (frame != NULL && frame->frame_type == frame_native)
548
        state |= JVMTI_THREAD_STATE_IN_NATIVE;
549
 
550
      using namespace java::lang;
551
      Thread$State *ts = thread->getState ();
552
      if (ts == Thread$State::RUNNABLE)
553
        state |= JVMTI_THREAD_STATE_RUNNABLE;
554
      else if (ts == Thread$State::BLOCKED)
555
        state |= JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER;
556
      else if (ts == Thread$State::TIMED_WAITING
557
               || ts == Thread$State::WAITING)
558
        {
559
          state |= JVMTI_THREAD_STATE_WAITING;
560
          state |= ((ts == Thread$State::WAITING)
561
                    ? JVMTI_THREAD_STATE_WAITING_INDEFINITELY
562
                    : JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT);
563
 
564
          /* FIXME: We don't have a way to tell
565
             the caller why the thread is suspended,
566
             i.e., JVMTI_THREAD_STATE_SLEEPING,
567
             JVMTI_THREAD_STATE_PARKED, and
568
             JVMTI_THREAD_STATE_IN_OBJECT_WAIT
569
             are never set. */
570
        }
571
    }
572
  else
573
    {
574
      using namespace java::lang;
575
      Thread$State *ts = thread->getState ();
576
      if (ts == Thread$State::TERMINATED)
577
        state |= JVMTI_THREAD_STATE_TERMINATED;
578
    }
579
 
580
  *thread_state_ptr = state;
581
  return JVMTI_ERROR_NONE;
582
}
583
 
584
static jvmtiError JNICALL
585
_Jv_JVMTI_CreateRawMonitor (MAYBE_UNUSED jvmtiEnv *env, const char *name,
586
                            jrawMonitorID *result)
587
{
588
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
589
  NULL_CHECK (name);
590
  NULL_CHECK (result);
591
  *result = (jrawMonitorID) _Jv_MallocUnchecked (sizeof (_Jv_rawMonitorID));
592
  if (*result == NULL)
593
    return JVMTI_ERROR_OUT_OF_MEMORY;
594
  _Jv_MutexInit (&(*result)->mutex);
595
  _Jv_CondInit (&(*result)->condition);
596
  return JVMTI_ERROR_NONE;
597
}
598
 
599
static jvmtiError JNICALL
600
_Jv_JVMTI_DestroyRawMonitor (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
601
{
602
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
603
  // Note we have no better way of knowing whether this object is
604
  // really a raw monitor.
605
  if (monitor == NULL)
606
    return JVMTI_ERROR_INVALID_MONITOR;
607
  // FIXME: perform checks on monitor, release it if this thread owns
608
  // it.
609
#ifdef _Jv_HaveMutexDestroy
610
  _Jv_MutexDestroy (&monitor->mutex);
611
#endif
612
  _Jv_Free (monitor);
613
  return JVMTI_ERROR_NONE;
614
}
615
 
616
static jvmtiError JNICALL
617
_Jv_JVMTI_RawMonitorEnter (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
618
{
619
  if (monitor == NULL)
620
    return JVMTI_ERROR_INVALID_MONITOR;
621
  _Jv_MutexLock (&monitor->mutex);
622
  return JVMTI_ERROR_NONE;
623
}
624
 
625
static jvmtiError JNICALL
626
_Jv_JVMTI_RawMonitorExit (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
627
{
628
  if (monitor == NULL)
629
    return JVMTI_ERROR_INVALID_MONITOR;
630
  if (_Jv_MutexUnlock (&monitor->mutex))
631
    return JVMTI_ERROR_NOT_MONITOR_OWNER;
632
  return JVMTI_ERROR_NONE;
633
}
634
 
635
static jvmtiError JNICALL
636
_Jv_JVMTI_RawMonitorWait (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor,
637
                          jlong millis)
638
{
639
  if (monitor == NULL)
640
    return JVMTI_ERROR_INVALID_MONITOR;
641
  int r = _Jv_CondWait (&monitor->condition, &monitor->mutex, millis, 0);
642
  if (r == _JV_NOT_OWNER)
643
    return JVMTI_ERROR_NOT_MONITOR_OWNER;
644
  if (r == _JV_INTERRUPTED)
645
    return JVMTI_ERROR_INTERRUPT;
646
  return JVMTI_ERROR_NONE;
647
}
648
 
649
static jvmtiError JNICALL
650
_Jv_JVMTI_RawMonitorNotify (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
651
{
652
  if (monitor == NULL)
653
    return JVMTI_ERROR_INVALID_MONITOR;
654
  if (_Jv_CondNotify (&monitor->condition, &monitor->mutex) == _JV_NOT_OWNER)
655
    return JVMTI_ERROR_NOT_MONITOR_OWNER;
656
  return JVMTI_ERROR_NONE;
657
}
658
 
659
static jvmtiError JNICALL
660
_Jv_JVMTI_RawMonitorNotifyAll (MAYBE_UNUSED jvmtiEnv *env,
661
                               jrawMonitorID monitor)
662
{
663
  if (monitor == NULL)
664
    return JVMTI_ERROR_INVALID_MONITOR;
665
  if (_Jv_CondNotifyAll (&monitor->condition, &monitor->mutex)
666
      == _JV_NOT_OWNER)
667
    return JVMTI_ERROR_NOT_MONITOR_OWNER;
668
  return JVMTI_ERROR_NONE;
669
}
670
 
671
static jvmtiError JNICALL
672
_Jv_JVMTI_SetBreakpoint (jvmtiEnv *env, jmethodID method, jlocation location)
673
{
674
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
675
 
676
  using namespace gnu::gcj::jvmti;
677
  Breakpoint *bp
678
    = BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
679
                                        location);
680
  if (bp == NULL)
681
    {
682
      jclass klass;
683
      jvmtiError err = env->GetMethodDeclaringClass (method, &klass);
684
      if (err != JVMTI_ERROR_NONE)
685
        return err;
686
 
687
      if (!_Jv_IsInterpretedClass (klass))
688
        return JVMTI_ERROR_INVALID_CLASS;
689
 
690
      _Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
691
      if (base == NULL)
692
        return JVMTI_ERROR_INVALID_METHODID;
693
 
694
      jint flags;
695
      err = env->GetMethodModifiers (method, &flags);
696
      if (err != JVMTI_ERROR_NONE)
697
        return err;
698
 
699
      if (flags & java::lang::reflect::Modifier::NATIVE)
700
        return JVMTI_ERROR_NATIVE_METHOD;
701
 
702
      _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
703
      if (imeth->get_insn (location) == NULL)
704
        return JVMTI_ERROR_INVALID_LOCATION;
705
 
706
      // Now the breakpoint can be safely installed
707
      bp = BreakpointManager::newBreakpoint (reinterpret_cast<jlong> (method),
708
                                             location);
709
    }
710
  else
711
    {
712
      // Duplicate breakpoints are not permitted by JVMTI
713
      return JVMTI_ERROR_DUPLICATE;
714
    }
715
 
716
  return JVMTI_ERROR_NONE;
717
}
718
 
719
static jvmtiError JNICALL
720
_Jv_JVMTI_ClearBreakpoint (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
721
                           jlocation location)
722
{
723
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
724
 
725
  using namespace gnu::gcj::jvmti;
726
 
727
  Breakpoint *bp
728
    = BreakpointManager::getBreakpoint (reinterpret_cast<jlong> (method),
729
                                        location);
730
  if (bp == NULL)
731
    return JVMTI_ERROR_NOT_FOUND;
732
 
733
  BreakpointManager::deleteBreakpoint (reinterpret_cast<jlong> (method), location);
734
  return JVMTI_ERROR_NONE;
735
}
736
 
737
static jvmtiError JNICALL
738
_Jv_JVMTI_Allocate (MAYBE_UNUSED jvmtiEnv *env, jlong size,
739
                    unsigned char **result)
740
{
741
  ILLEGAL_ARGUMENT (size < 0);
742
  NULL_CHECK (result);
743
  if (size == 0)
744
    *result = NULL;
745
  else
746
    {
747
      *result = (unsigned char *) _Jv_MallocUnchecked (size);
748
      if (*result == NULL)
749
        return JVMTI_ERROR_OUT_OF_MEMORY;
750
    }
751
  return JVMTI_ERROR_NONE;
752
}
753
 
754
static jvmtiError JNICALL
755
_Jv_JVMTI_Deallocate (MAYBE_UNUSED jvmtiEnv *env, unsigned char *mem)
756
{
757
  if (mem != NULL)
758
    _Jv_Free (mem);
759
  return JVMTI_ERROR_NONE;
760
}
761
 
762
static jvmtiError JNICALL
763
_Jv_JVMTI_GetClassStatus (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
764
                          jint *status_ptr)
765
{
766
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
767
  NULL_CHECK (status_ptr);
768
  if (klass == NULL)
769
    return JVMTI_ERROR_INVALID_CLASS;
770
 
771
  if (klass->isArray ())
772
    *status_ptr = JVMTI_CLASS_STATUS_ARRAY;
773
  else if (klass->isPrimitive ())
774
    *status_ptr  = JVMTI_CLASS_STATUS_PRIMITIVE;
775
  else
776
    {
777
      jbyte state = _Jv_GetClassState (klass);
778
      *status_ptr = 0;
779
      if (state >= JV_STATE_LINKED)
780
        (*status_ptr) |= JVMTI_CLASS_STATUS_VERIFIED;
781
      if (state >= JV_STATE_PREPARED)
782
        (*status_ptr) |= JVMTI_CLASS_STATUS_PREPARED;
783
      if (state == JV_STATE_ERROR || state == JV_STATE_PHANTOM)
784
        (*status_ptr) |= JVMTI_CLASS_STATUS_ERROR;
785
      else if (state == JV_STATE_DONE)
786
        (*status_ptr) |= JVMTI_CLASS_STATUS_INITIALIZED;
787
    }
788
 
789
  return JVMTI_ERROR_NONE;
790
}
791
 
792
static jvmtiError JNICALL
793
_Jv_JVMTI_GetClassModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
794
                             jint *mods)
795
{
796
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
797
  // Don't bother checking KLASS' type.
798
  if (klass == NULL)
799
    return JVMTI_ERROR_INVALID_CLASS;
800
  NULL_CHECK (mods);
801
  *mods = klass->getModifiers();
802
  return JVMTI_ERROR_NONE;
803
}
804
 
805
static jvmtiError JNICALL
806
_Jv_JVMTI_GetClassMethods (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
807
                           jint *count_ptr, jmethodID **methods_ptr)
808
{
809
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
810
  // FIXME: capability can_maintain_original_method_order
811
  // Don't bother checking KLASS' type.
812
  if (klass == NULL)
813
    return JVMTI_ERROR_INVALID_CLASS;
814
  NULL_CHECK (count_ptr);
815
  NULL_CHECK (methods_ptr);
816
  *count_ptr = JvNumMethods(klass);
817
 
818
  *methods_ptr
819
    = (jmethodID *) _Jv_MallocUnchecked (*count_ptr * sizeof (jmethodID));
820
  if (*methods_ptr == NULL)
821
    return JVMTI_ERROR_OUT_OF_MEMORY;
822
 
823
  jmethodID start = JvGetFirstMethod (klass);
824
  for (jint i = 0; i < *count_ptr; ++i)
825
    // FIXME: correct?
826
    (*methods_ptr)[i] = start + i;
827
 
828
  return JVMTI_ERROR_NONE;
829
}
830
 
831
static jvmtiError JNICALL
832
_Jv_JVMTI_IsInterface (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
833
                       jboolean *result)
834
{
835
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
836
  if (klass == NULL)
837
    return JVMTI_ERROR_INVALID_CLASS;
838
  NULL_CHECK (result);
839
  *result = klass->isInterface();
840
  return JVMTI_ERROR_NONE;
841
}
842
 
843
static jvmtiError JNICALL
844
_Jv_JVMTI_IsArrayClass (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
845
                        jboolean *result)
846
{
847
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
848
  if (klass == NULL)
849
    return JVMTI_ERROR_INVALID_CLASS;
850
  NULL_CHECK (result);
851
  *result = klass->isArray();
852
  return JVMTI_ERROR_NONE;
853
}
854
 
855
static jvmtiError JNICALL
856
_Jv_JVMTI_GetClassLoader (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
857
                          jobject *result)
858
{
859
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
860
  if (klass == NULL)
861
    return JVMTI_ERROR_INVALID_CLASS;
862
  NULL_CHECK (result);
863
  *result = klass->getClassLoaderInternal();
864
  return JVMTI_ERROR_NONE;
865
}
866
 
867
static jvmtiError JNICALL
868
_Jv_JVMTI_GetObjectHashCode (MAYBE_UNUSED jvmtiEnv *env, jobject obj,
869
                             jint *result)
870
{
871
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
872
  if (obj == NULL)
873
    return JVMTI_ERROR_INVALID_OBJECT;
874
  NULL_CHECK (result);
875
  *result = _Jv_HashCode (obj);
876
  return JVMTI_ERROR_NONE;
877
}
878
 
879
static jvmtiError JNICALL
880
_Jv_JVMTI_GetFieldModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
881
                             jfieldID field, jint *result)
882
{
883
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
884
  if (klass == NULL)
885
    return JVMTI_ERROR_INVALID_CLASS;
886
  if (field == NULL)
887
    return JVMTI_ERROR_INVALID_FIELDID;
888
  NULL_CHECK (result);
889
  *result = field->getModifiers();
890
  return JVMTI_ERROR_NONE;
891
}
892
 
893
static jvmtiError JNICALL
894
_Jv_JVMTI_IsFieldSynthetic (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
895
                            jfieldID field, jboolean *result)
896
{
897
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
898
  if (klass == NULL)
899
    return JVMTI_ERROR_INVALID_CLASS;
900
  if (field == NULL)
901
    return JVMTI_ERROR_INVALID_FIELDID;
902
  NULL_CHECK (result);
903
 
904
  // FIXME: capability can_get_synthetic_attribute
905
  *result = ((field->getModifiers() & java::lang::reflect::Modifier::SYNTHETIC)
906
             != 0);
907
  return JVMTI_ERROR_NONE;
908
}
909
 
910
static jvmtiError JNICALL
911
_Jv_JVMTI_GetMethodName (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
912
                         char **name_ptr, char **signature_ptr,
913
                         char **generic_ptr)
914
{
915
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
916
 
917
  if (method == NULL)
918
    return JVMTI_ERROR_INVALID_METHODID;
919
 
920
  if (name_ptr != NULL)
921
    {
922
      int len = static_cast<int> (method->name->len ());
923
      *name_ptr = (char *) _Jv_MallocUnchecked (len + 1);
924
      if (*name_ptr == NULL)
925
        return JVMTI_ERROR_OUT_OF_MEMORY;
926
      strncpy (*name_ptr, method->name->chars (), len);
927
      (*name_ptr)[len] = '\0';
928
    }
929
 
930
  if (signature_ptr != NULL)
931
    {
932
      int len = static_cast<int> (method->signature->len ());
933
      *signature_ptr = (char *) _Jv_MallocUnchecked (len + 1);
934
      if (*signature_ptr == NULL)
935
        {
936
          if (name_ptr != NULL)
937
            _Jv_Free (*name_ptr);
938
          return JVMTI_ERROR_OUT_OF_MEMORY;
939
        }
940
      strncpy (*signature_ptr, method->signature->chars (), len);
941
      (*signature_ptr)[len] = '\0';
942
    }
943
 
944
  if (generic_ptr != NULL)
945
    {
946
      *generic_ptr = NULL;
947
    }
948
 
949
  return JVMTI_ERROR_NONE;
950
}
951
 
952
static jvmtiError JNICALL
953
_Jv_JVMTI_GetMethodModifiers (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
954
                              jint *result)
955
{
956
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
957
  if (method == NULL)
958
    return JVMTI_ERROR_INVALID_METHODID;
959
  NULL_CHECK (result);
960
 
961
  // FIXME: mask off some internal bits...
962
  *result = method->accflags;
963
  return JVMTI_ERROR_NONE;
964
}
965
 
966
static jvmtiError JNICALL
967
_Jv_JVMTI_GetLineNumberTable (jvmtiEnv *env, jmethodID method,
968
                              jint *entry_count_ptr,
969
                              jvmtiLineNumberEntry **table_ptr)
970
{
971
  NULL_CHECK (entry_count_ptr);
972
  NULL_CHECK (table_ptr);
973
 
974
  jclass klass;
975
  jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
976
  if (jerr != JVMTI_ERROR_NONE)
977
    return jerr;
978
 
979
  _Jv_MethodBase *base = _Jv_FindInterpreterMethod (klass, method);
980
  if (base == NULL)
981
    return JVMTI_ERROR_INVALID_METHODID;
982
 
983
  if (java::lang::reflect::Modifier::isNative (method->accflags)
984
      || !_Jv_IsInterpretedClass (klass))
985
    return JVMTI_ERROR_NATIVE_METHOD;
986
 
987
  _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *> (base);
988
  jlong start, end;
989
  jintArray lines = NULL;
990
  jlongArray indices = NULL;
991
  imeth->get_line_table (start, end, lines, indices);
992
  if (lines == NULL)
993
    return JVMTI_ERROR_ABSENT_INFORMATION;
994
 
995
  jvmtiLineNumberEntry *table;
996
  jsize len = lines->length * sizeof (jvmtiLineNumberEntry);
997
  table = (jvmtiLineNumberEntry *) _Jv_MallocUnchecked (len);
998
  if (table == NULL)
999
    return JVMTI_ERROR_OUT_OF_MEMORY;
1000
 
1001
  jint *line = elements (lines);
1002
  jlong *index = elements (indices);
1003
  for (int i = 0; i < lines->length; ++i)
1004
    {
1005
      table[i].start_location = index[i];
1006
      table[i].line_number = line[i];
1007
    }
1008
 
1009
  *table_ptr = table;
1010
  *entry_count_ptr = lines->length;
1011
  return JVMTI_ERROR_NONE;
1012
}
1013
 
1014
static jvmtiError JNICALL
1015
_Jv_JVMTI_GetLocalVariableTable (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
1016
                                 jint *num_locals,
1017
                                 jvmtiLocalVariableEntry **locals)
1018
{
1019
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
1020
  NULL_CHECK (num_locals);
1021
  NULL_CHECK (locals);
1022
 
1023
  CHECK_FOR_NATIVE_METHOD(method);
1024
 
1025
  jclass klass;
1026
  jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
1027
  if (jerr != JVMTI_ERROR_NONE)
1028
    return jerr;
1029
 
1030
  _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *>
1031
                              (_Jv_FindInterpreterMethod (klass, method));
1032
 
1033
  if (imeth == NULL)
1034
    return JVMTI_ERROR_INVALID_METHODID;
1035
 
1036
  jerr = env->GetMaxLocals (method, num_locals);
1037
  if (jerr != JVMTI_ERROR_NONE)
1038
    return jerr;
1039
 
1040
  jerr = env->Allocate (static_cast<jlong>
1041
                          ((*num_locals) * sizeof (jvmtiLocalVariableEntry)),
1042
                        reinterpret_cast<unsigned char **> (locals));
1043
 
1044
  if (jerr != JVMTI_ERROR_NONE)
1045
    return jerr;
1046
 
1047
  //the slot in the methods local_var_table to get
1048
  int table_slot = 0;
1049
  char *name;
1050
  char *sig;
1051
  char *generic_sig;
1052
 
1053
  while (table_slot < *num_locals
1054
         && imeth->get_local_var_table (&name, &sig, &generic_sig,
1055
                                 &((((*locals)[table_slot].start_location))),
1056
                                 &((*locals)[table_slot].length),
1057
                                 &((*locals)[table_slot].slot),
1058
                                 table_slot)
1059
            >= 0)
1060
    {
1061
      char **str_ptr = &(*locals)[table_slot].name;
1062
      jerr = env->Allocate (static_cast<jlong> (strlen (name) + 1),
1063
                             reinterpret_cast<unsigned char **> (str_ptr));
1064
      if (jerr != JVMTI_ERROR_NONE)
1065
        return jerr;
1066
      strcpy ((*locals)[table_slot].name, name);
1067
 
1068
      str_ptr = &(*locals)[table_slot].signature;
1069
      jerr = env->Allocate (static_cast<jlong> (strlen (sig) + 1),
1070
                               reinterpret_cast<unsigned char **> (str_ptr));
1071
      if (jerr != JVMTI_ERROR_NONE)
1072
        return jerr;
1073
      strcpy ((*locals)[table_slot].signature, sig);
1074
 
1075
      str_ptr = &(*locals)[table_slot].generic_signature;
1076
      jerr = env->Allocate (static_cast<jlong> (strlen (generic_sig) + 1),
1077
                               reinterpret_cast<unsigned char **> (str_ptr));
1078
      if (jerr != JVMTI_ERROR_NONE)
1079
        return jerr;
1080
      strcpy ((*locals)[table_slot].generic_signature, generic_sig);
1081
 
1082
      table_slot++;
1083
    }
1084
 
1085
  if (table_slot == 0)
1086
    return JVMTI_ERROR_ABSENT_INFORMATION;
1087
 
1088
  // If there are double or long variables in the table, the the table will be
1089
  // smaller than the max number of slots, so correct for this here.
1090
  if ((table_slot) < *num_locals)
1091
    *num_locals = table_slot;
1092
 
1093
  return JVMTI_ERROR_NONE;
1094
}
1095
 
1096
static jvmtiError JNICALL
1097
_Jv_JVMTI_IsMethodNative (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
1098
                          jboolean *result)
1099
{
1100
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1101
  if (method == NULL)
1102
    return JVMTI_ERROR_INVALID_METHODID;
1103
  NULL_CHECK (result);
1104
 
1105
  *result = ((method->accflags & java::lang::reflect::Modifier::NATIVE) != 0);
1106
  return JVMTI_ERROR_NONE;
1107
}
1108
 
1109
static jvmtiError JNICALL
1110
_Jv_JVMTI_IsMethodSynthetic (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
1111
                             jboolean *result)
1112
{
1113
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1114
  if (method == NULL)
1115
    return JVMTI_ERROR_INVALID_METHODID;
1116
  NULL_CHECK (result);
1117
 
1118
  // FIXME capability can_get_synthetic_attribute
1119
 
1120
  *result = ((method->accflags & java::lang::reflect::Modifier::SYNTHETIC)
1121
             != 0);
1122
  return JVMTI_ERROR_NONE;
1123
}
1124
 
1125
static jvmtiError JNICALL
1126
_Jv_JVMTI_GetMaxLocals (jvmtiEnv *env, jmethodID method, jint *max_locals)
1127
{
1128
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1129
  NULL_CHECK (max_locals);
1130
 
1131
  CHECK_FOR_NATIVE_METHOD (method);
1132
 
1133
  jclass klass;
1134
  jvmtiError jerr = env->GetMethodDeclaringClass (method, &klass);
1135
  if (jerr != JVMTI_ERROR_NONE)
1136
    return jerr;
1137
 
1138
  _Jv_InterpMethod *imeth = reinterpret_cast<_Jv_InterpMethod *>
1139
                              (_Jv_FindInterpreterMethod (klass, method));
1140
 
1141
  if (imeth == NULL)
1142
    return JVMTI_ERROR_INVALID_METHODID;
1143
 
1144
  *max_locals = imeth->get_max_locals ();
1145
 
1146
  return JVMTI_ERROR_NONE;
1147
}
1148
 
1149
static jvmtiError JNICALL
1150
_Jv_JVMTI_GetArgumentsSize (jvmtiEnv *env, jmethodID method, jint *size)
1151
{
1152
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1153
  NULL_CHECK (size);
1154
 
1155
  CHECK_FOR_NATIVE_METHOD (method);
1156
 
1157
  jvmtiError jerr;
1158
  char *sig;
1159
  jint num_slots = 0;
1160
 
1161
  jerr = env->GetMethodName (method, NULL, &sig, NULL);
1162
  if (jerr != JVMTI_ERROR_NONE)
1163
    return jerr;
1164
 
1165
  // If the method is non-static add a slot for the "this" pointer.
1166
  if ((method->accflags & java::lang::reflect::Modifier::STATIC) == 0)
1167
    num_slots++;
1168
 
1169
  for (int i = 0; sig[i] != ')'; i++)
1170
    {
1171
      if (sig[i] == 'Z' || sig[i] == 'B' || sig[i] == 'C' || sig[i] == 'S'
1172
          || sig[i] == 'I' || sig[i] == 'F')
1173
        num_slots++;
1174
      else if (sig[i] == 'J' || sig[i] == 'D')
1175
        {
1176
          // If this is an array of wide types it uses a single slot
1177
          if (i > 0 && sig[i - 1] == '[')
1178
            num_slots++;
1179
          else
1180
            num_slots += 2;
1181
        }
1182
      else if (sig[i] == 'L')
1183
        {
1184
          num_slots++;
1185
          while (sig[i] != ';')
1186
            i++;
1187
        }
1188
    }
1189
 
1190
  *size = num_slots;
1191
  return JVMTI_ERROR_NONE;
1192
}
1193
 
1194
static jvmtiError JNICALL
1195
_Jv_JVMTI_GetMethodDeclaringClass (MAYBE_UNUSED jvmtiEnv *env,
1196
                                   jmethodID method,
1197
                                   jclass *declaring_class_ptr)
1198
{
1199
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
1200
  NULL_CHECK (declaring_class_ptr);
1201
 
1202
  jclass klass = _Jv_GetMethodDeclaringClass (method);
1203
  if (klass != NULL)
1204
    {
1205
      *declaring_class_ptr = klass;
1206
      return JVMTI_ERROR_NONE;
1207
    }
1208
 
1209
  return JVMTI_ERROR_INVALID_METHODID;
1210
}
1211
 
1212
static jvmtiError JNICALL
1213
_Jv_JVMTI_GetClassLoaderClasses (MAYBE_UNUSED jvmtiEnv *env,
1214
                                 jobject init_loader,
1215
                                 jint *count_ptr,
1216
                                 jclass **result_ptr)
1217
{
1218
  using namespace java::lang;
1219
  using namespace java::util;
1220
 
1221
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
1222
  NULL_CHECK (count_ptr);
1223
  NULL_CHECK (result_ptr);
1224
 
1225
  ClassLoader *loader = (ClassLoader *) init_loader;
1226
  if (loader == NULL)
1227
    loader = VMClassLoader::bootLoader;
1228
 
1229
  Collection *values = loader->loadedClasses->values();
1230
  jobjectArray array = values->toArray();
1231
  *count_ptr = array->length;
1232
  jobject *elts = elements (array);
1233
  jclass *result
1234
    = (jclass *) _Jv_MallocUnchecked (*count_ptr * sizeof (jclass));
1235
  if (result == NULL)
1236
    return JVMTI_ERROR_OUT_OF_MEMORY;
1237
 
1238
  // FIXME: JNI references...
1239
  memcpy (result, elts, *count_ptr * sizeof (jclass));
1240
 
1241
  *result_ptr = result;
1242
 
1243
  return JVMTI_ERROR_NONE;
1244
}
1245
 
1246
static jvmtiError JNICALL
1247
_Jv_JVMTI_GetStackTrace (MAYBE_UNUSED jvmtiEnv *env, jthread thread,
1248
                         jint start_depth, jint max_frames,
1249
                         jvmtiFrameInfo *frames, jint *frame_count)
1250
{
1251
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
1252
 
1253
  ILLEGAL_ARGUMENT (max_frames < 0);
1254
 
1255
  NULL_CHECK (frames);
1256
  NULL_CHECK (frame_count);
1257
 
1258
  using namespace java::lang;
1259
 
1260
  THREAD_DEFAULT_TO_CURRENT (thread);
1261
  THREAD_CHECK_VALID (thread);
1262
  THREAD_CHECK_IS_ALIVE (thread);
1263
 
1264
  jvmtiError jerr = env->GetFrameCount (thread, frame_count);
1265
  if (jerr != JVMTI_ERROR_NONE)
1266
    return jerr;
1267
 
1268
  // start_depth can be either a positive number, indicating the depth of the
1269
  // stack at which to begin the trace, or a negative number indicating the
1270
  // number of frames at the bottom of the stack to exclude.  These checks
1271
  // ensure that it is a valid value in either case
1272
 
1273
  ILLEGAL_ARGUMENT (start_depth >= (*frame_count));
1274
  ILLEGAL_ARGUMENT (start_depth < (-(*frame_count)));
1275
 
1276
  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
1277
 
1278
  // If start_depth is negative use this to determine at what depth to start
1279
  // the trace by adding it to the length of the call stack.  This allows the
1280
  // use of the same frame "discarding" mechanism as for a positive start_depth
1281
  if (start_depth < 0)
1282
    start_depth = *frame_count + start_depth;
1283
 
1284
  // If start_depth > 0 "remove" start_depth frames from the beginning
1285
  // of the stack before beginning the trace by moving along the frame list.
1286
  while (start_depth > 0)
1287
    {
1288
      frame = frame->next;
1289
      start_depth--;
1290
      (*frame_count)--;
1291
    }
1292
 
1293
  // Now check to see if the array supplied by the agent is large enough to
1294
  // hold frame_count frames, after adjustment for start_depth.
1295
  if ((*frame_count) > max_frames)
1296
    (*frame_count) = max_frames;
1297
 
1298
  for (int i = 0; i < (*frame_count); i++)
1299
    {
1300
      frames[i].method = frame->self->get_method ();
1301
 
1302
      // Set the location in the frame, native frames have location = -1
1303
      if (frame->frame_type == frame_interpreter)
1304
        {
1305
          _Jv_InterpMethod *imeth
1306
            = static_cast<_Jv_InterpMethod *> (frame->self);
1307
          _Jv_InterpFrame *interp_frame
1308
            = static_cast<_Jv_InterpFrame *> (frame);
1309
          frames[i].location = imeth->insn_index (interp_frame->get_pc ());
1310
        }
1311
      else
1312
        frames[i].location = -1;
1313
 
1314
      frame = frame->next;
1315
    }
1316
 
1317
  return JVMTI_ERROR_NONE;
1318
}
1319
 
1320
static jvmtiError JNICALL
1321
_Jv_JVMTI_ForceGarbageCollection (MAYBE_UNUSED jvmtiEnv *env)
1322
{
1323
  REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
1324
  _Jv_RunGC();
1325
  return JVMTI_ERROR_NONE;
1326
}
1327
 
1328
static jvmtiError JNICALL
1329
_Jv_JVMTI_SetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
1330
                               const jniNativeInterface *function_table)
1331
{
1332
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1333
  NULL_CHECK (function_table);
1334
  memcpy (&_Jv_JNIFunctions, function_table, sizeof (jniNativeInterface));
1335
  return JVMTI_ERROR_NONE;
1336
}
1337
 
1338
static jvmtiError JNICALL
1339
_Jv_JVMTI_GetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
1340
                               jniNativeInterface **function_table)
1341
{
1342
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1343
  NULL_CHECK (function_table);
1344
  *function_table
1345
    = (jniNativeInterface *) _Jv_MallocUnchecked (sizeof (jniNativeInterface));
1346
  if (*function_table == NULL)
1347
    return JVMTI_ERROR_OUT_OF_MEMORY;
1348
  memcpy (*function_table, &_Jv_JNIFunctions, sizeof (jniNativeInterface));
1349
  return JVMTI_ERROR_NONE;
1350
}
1351
 
1352
static jvmtiError JNICALL
1353
_Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env)
1354
{
1355
  NULL_CHECK (env);
1356
 
1357
  if (_jvmtiEnvironments == NULL)
1358
    return JVMTI_ERROR_INVALID_ENVIRONMENT;
1359
  else
1360
    {
1361
      _envListLock->writeLock ()->lock ();
1362
      if (_jvmtiEnvironments->env == env)
1363
        {
1364
          struct jvmti_env_list *next = _jvmtiEnvironments->next;
1365
          _Jv_Free (_jvmtiEnvironments);
1366
          _jvmtiEnvironments = next;
1367
        }
1368
      else
1369
        {
1370
          struct jvmti_env_list *e = _jvmtiEnvironments;
1371
          while (e->next != NULL && e->next->env != env)
1372
            e = e->next;
1373
          if (e->next == NULL)
1374
            {
1375
              _envListLock->writeLock ()->unlock ();
1376
              return JVMTI_ERROR_INVALID_ENVIRONMENT;
1377
            }
1378
 
1379
          struct jvmti_env_list *next = e->next->next;
1380
          _Jv_Free (e->next);
1381
          e->next = next;
1382
        }
1383
      _envListLock->writeLock ()->unlock ();
1384
    }
1385
 
1386
  _Jv_Free (env);
1387
 
1388
  check_enabled_events ();
1389
 
1390
  return JVMTI_ERROR_NONE;
1391
}
1392
 
1393
static jvmtiError JNICALL
1394
_Jv_JVMTI_GetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
1395
                             char **result)
1396
{
1397
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
1398
  NULL_CHECK (property);
1399
  NULL_CHECK (result);
1400
 
1401
  jstring name = JvNewStringUTF(property);
1402
  jstring result_str = gnu::classpath::SystemProperties::getProperty(name);
1403
 
1404
  if (result_str == NULL)
1405
    return JVMTI_ERROR_NOT_AVAILABLE;
1406
 
1407
  int len = JvGetStringUTFLength (result_str);
1408
  *result = (char *) _Jv_MallocUnchecked (len + 1);
1409
  if (*result == NULL)
1410
    return JVMTI_ERROR_OUT_OF_MEMORY;
1411
  JvGetStringUTFRegion (result_str, 0, result_str->length(), *result);
1412
  (*result)[len] = '\0';
1413
 
1414
  return JVMTI_ERROR_NONE;
1415
}
1416
 
1417
static jvmtiError JNICALL
1418
_Jv_JVMTI_SetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
1419
                             const char *value)
1420
{
1421
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
1422
 
1423
  NULL_CHECK (property);
1424
  if (value == NULL)
1425
    {
1426
      // FIXME: When would a property not be writeable?
1427
      return JVMTI_ERROR_NONE;
1428
    }
1429
 
1430
  jstring prop_str = JvNewStringUTF(property);
1431
  jstring value_str = JvNewStringUTF(value);
1432
  gnu::classpath::SystemProperties::setProperty(prop_str, value_str);
1433
  return JVMTI_ERROR_NONE;
1434
}
1435
 
1436
static jvmtiError JNICALL
1437
_Jv_JVMTI_GetTime (MAYBE_UNUSED jvmtiEnv *env, jlong *nanos_ptr)
1438
{
1439
  NULL_CHECK (nanos_ptr);
1440
  *nanos_ptr = _Jv_platform_nanotime();
1441
  return JVMTI_ERROR_NONE;
1442
}
1443
 
1444
static jvmtiError JNICALL
1445
_Jv_JVMTI_GetAvailableProcessors (MAYBE_UNUSED jvmtiEnv *env,
1446
                                  jint *nprocessors_ptr)
1447
{
1448
  NULL_CHECK (nprocessors_ptr);
1449
#ifdef _SC_NPROCESSORS_ONLN
1450
  *nprocessors_ptr = sysconf(_SC_NPROCESSORS_ONLN);
1451
#else
1452
  *nprocessors_ptr = 1;
1453
#endif
1454
  return JVMTI_ERROR_NONE;
1455
}
1456
 
1457
static jvmtiError JNICALL
1458
_Jv_JVMTI_AddToBootstrapClassLoaderSearch (MAYBE_UNUSED jvmtiEnv *env,
1459
                                           const char *segment)
1460
{
1461
  using namespace java::lang;
1462
  using namespace java::net;
1463
  using namespace gnu::gcj::runtime;
1464
 
1465
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
1466
  NULL_CHECK (segment);
1467
 
1468
  jstring str_segment = JvNewStringUTF(segment);
1469
  URL *url;
1470
  try
1471
    {
1472
      url = new URL(JvNewStringUTF("file"), NULL, str_segment);
1473
    }
1474
  catch (jthrowable ignore)
1475
    {
1476
      return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1477
    }
1478
 
1479
  BootClassLoader *loader = VMClassLoader::bootLoader;
1480
  // Don't call this too early.
1481
  // assert (loader != NULL);
1482
  loader->addURL(url);
1483
  return JVMTI_ERROR_NONE;
1484
}
1485
 
1486
static jvmtiError JNICALL
1487
_Jv_JVMTI_SetVerboseFlag (MAYBE_UNUSED jvmtiEnv *env, jvmtiVerboseFlag flag,
1488
                          jboolean value)
1489
{
1490
  switch (flag)
1491
    {
1492
    case JVMTI_VERBOSE_OTHER:
1493
    case JVMTI_VERBOSE_GC:
1494
    case JVMTI_VERBOSE_JNI:
1495
      // Ignore.
1496
      break;
1497
    case JVMTI_VERBOSE_CLASS:
1498
      gcj::verbose_class_flag = value;
1499
      break;
1500
    default:
1501
      return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1502
    }
1503
  return JVMTI_ERROR_NONE;
1504
}
1505
 
1506
static jvmtiError JNICALL
1507
_Jv_JVMTI_GetObjectSize (MAYBE_UNUSED jvmtiEnv *env, jobject object,
1508
                         jlong *result)
1509
{
1510
  REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
1511
  if (object == NULL)
1512
    return JVMTI_ERROR_INVALID_OBJECT;
1513
  NULL_CHECK (result);
1514
 
1515
  jclass klass = object->getClass();
1516
  if (klass->isArray())
1517
    {
1518
      jclass comp = klass->getComponentType();
1519
      jint base
1520
        = (jint) (_Jv_uintptr_t) _Jv_GetArrayElementFromElementType(NULL,
1521
                                                                    klass->getComponentType());
1522
      // FIXME: correct for primitive types?
1523
      jint compSize = comp->size();
1524
      __JArray *array = (__JArray *) object;
1525
      *result = base + array->length * compSize;
1526
    }
1527
  else
1528
    {
1529
      // Note that if OBJECT is a String then it may (if
1530
      // str->data==str) take more space.  Do we care?
1531
      *result = klass->size();
1532
    }
1533
  return JVMTI_ERROR_NONE;
1534
}
1535
 
1536
/* An event is enabled only if it has both an event handler
1537
   and it is enabled in the environment. */
1538
static void
1539
check_enabled_event (jvmtiEvent type)
1540
{
1541
  bool *enabled;
1542
  int offset;
1543
 
1544
#define GET_OFFSET(Event)                               \
1545
  do                                                    \
1546
    {                                                   \
1547
      enabled = &JVMTI::Event;                          \
1548
      offset = offsetof (jvmtiEventCallbacks, Event);   \
1549
    }                                                   \
1550
  while (0)
1551
 
1552
  switch (type)
1553
    {
1554
    case JVMTI_EVENT_VM_INIT:
1555
      GET_OFFSET (VMInit);
1556
      break;
1557
 
1558
    case JVMTI_EVENT_VM_DEATH:
1559
      GET_OFFSET (VMDeath);
1560
      break;
1561
 
1562
    case JVMTI_EVENT_THREAD_START:
1563
      GET_OFFSET (ThreadStart);
1564
      break;
1565
 
1566
    case JVMTI_EVENT_THREAD_END:
1567
      GET_OFFSET (ThreadEnd);
1568
      break;
1569
 
1570
    case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
1571
      GET_OFFSET (ClassFileLoadHook);
1572
      break;
1573
 
1574
    case JVMTI_EVENT_CLASS_LOAD:
1575
      GET_OFFSET (ClassLoad);
1576
      break;
1577
 
1578
    case JVMTI_EVENT_CLASS_PREPARE:
1579
      GET_OFFSET (ClassPrepare);
1580
      break;
1581
 
1582
    case JVMTI_EVENT_VM_START:
1583
      GET_OFFSET (VMStart);
1584
      break;
1585
 
1586
    case JVMTI_EVENT_EXCEPTION:
1587
      GET_OFFSET (Exception);
1588
      break;
1589
 
1590
    case JVMTI_EVENT_EXCEPTION_CATCH:
1591
      GET_OFFSET (ExceptionCatch);
1592
      break;
1593
 
1594
    case JVMTI_EVENT_SINGLE_STEP:
1595
      GET_OFFSET (SingleStep);
1596
      break;
1597
 
1598
    case JVMTI_EVENT_FRAME_POP:
1599
      GET_OFFSET (FramePop);
1600
      break;
1601
 
1602
    case JVMTI_EVENT_BREAKPOINT:
1603
      GET_OFFSET (Breakpoint);
1604
      break;
1605
 
1606
    case JVMTI_EVENT_FIELD_ACCESS:
1607
      GET_OFFSET (FieldAccess);
1608
      break;
1609
 
1610
    case JVMTI_EVENT_FIELD_MODIFICATION:
1611
      GET_OFFSET (FieldModification);
1612
      break;
1613
 
1614
    case JVMTI_EVENT_METHOD_ENTRY:
1615
      GET_OFFSET (MethodEntry);
1616
      break;
1617
 
1618
    case JVMTI_EVENT_METHOD_EXIT:
1619
      GET_OFFSET (MethodExit);
1620
      break;
1621
 
1622
    case JVMTI_EVENT_NATIVE_METHOD_BIND:
1623
      GET_OFFSET (NativeMethodBind);
1624
      break;
1625
 
1626
    case JVMTI_EVENT_COMPILED_METHOD_LOAD:
1627
      GET_OFFSET (CompiledMethodLoad);
1628
      break;
1629
 
1630
    case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
1631
      GET_OFFSET (CompiledMethodUnload);
1632
      break;
1633
 
1634
    case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
1635
      GET_OFFSET (DynamicCodeGenerated);
1636
      break;
1637
 
1638
    case JVMTI_EVENT_DATA_DUMP_REQUEST:
1639
      GET_OFFSET (DataDumpRequest);
1640
      break;
1641
 
1642
    case JVMTI_EVENT_MONITOR_WAIT:
1643
      GET_OFFSET (MonitorWait);
1644
      break;
1645
 
1646
    case JVMTI_EVENT_MONITOR_WAITED:
1647
      GET_OFFSET (MonitorWaited);
1648
      break;
1649
 
1650
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
1651
      GET_OFFSET (MonitorContendedEnter);
1652
      break;
1653
 
1654
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
1655
      GET_OFFSET (MonitorContendedEntered);
1656
      break;
1657
 
1658
    case JVMTI_EVENT_GARBAGE_COLLECTION_START:
1659
      GET_OFFSET (GarbageCollectionStart);
1660
      break;
1661
 
1662
    case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
1663
      GET_OFFSET (GarbageCollectionFinish);
1664
      break;
1665
 
1666
    case JVMTI_EVENT_OBJECT_FREE:
1667
      GET_OFFSET (ObjectFree);
1668
      break;
1669
 
1670
    case JVMTI_EVENT_VM_OBJECT_ALLOC:
1671
      GET_OFFSET (VMObjectAlloc);
1672
      break;
1673
 
1674
    default:
1675
      fprintf (stderr,
1676
               "libgcj: check_enabled_event for unknown JVMTI event (%d)\n",
1677
               (int) type);
1678
      return;
1679
    }
1680
#undef GET_OFFSET
1681
 
1682
  int index = EVENT_INDEX (type); // safe since caller checks this
1683
 
1684
  if (_jvmtiEnvironments != NULL)
1685
    {
1686
      _envListLock->readLock ()->lock ();
1687
      struct jvmti_env_list *e;
1688
      FOREACH_ENVIRONMENT (e)
1689
        {
1690
          char *addr
1691
            = reinterpret_cast<char *> (&e->env->callbacks) + offset;
1692
          void **callback = reinterpret_cast<void **> (addr);
1693
          if (e->env->enabled[index] && *callback != NULL)
1694
            {
1695
              *enabled = true;
1696
              _envListLock->readLock ()->unlock ();
1697
              return;
1698
            }
1699
        }
1700
 
1701
      _envListLock->readLock ()->unlock ();
1702
    }
1703
 
1704
  *enabled = false;
1705
}
1706
 
1707
static void
1708
check_enabled_events ()
1709
{
1710
  check_enabled_event (JVMTI_EVENT_VM_INIT);
1711
  check_enabled_event (JVMTI_EVENT_VM_DEATH);
1712
  check_enabled_event (JVMTI_EVENT_THREAD_START);
1713
  check_enabled_event (JVMTI_EVENT_THREAD_END);
1714
  check_enabled_event (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK);
1715
  check_enabled_event (JVMTI_EVENT_CLASS_LOAD);
1716
  check_enabled_event (JVMTI_EVENT_CLASS_PREPARE);
1717
  check_enabled_event (JVMTI_EVENT_VM_START);
1718
  check_enabled_event (JVMTI_EVENT_EXCEPTION);
1719
  check_enabled_event (JVMTI_EVENT_EXCEPTION_CATCH);
1720
  check_enabled_event (JVMTI_EVENT_SINGLE_STEP);
1721
  check_enabled_event (JVMTI_EVENT_FRAME_POP);
1722
  check_enabled_event (JVMTI_EVENT_BREAKPOINT);
1723
  check_enabled_event (JVMTI_EVENT_FIELD_ACCESS);
1724
  check_enabled_event (JVMTI_EVENT_FIELD_MODIFICATION);
1725
  check_enabled_event (JVMTI_EVENT_METHOD_ENTRY);
1726
  check_enabled_event (JVMTI_EVENT_METHOD_EXIT);
1727
  check_enabled_event (JVMTI_EVENT_NATIVE_METHOD_BIND);
1728
  check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_LOAD);
1729
  check_enabled_event (JVMTI_EVENT_COMPILED_METHOD_UNLOAD);
1730
  check_enabled_event (JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
1731
  check_enabled_event (JVMTI_EVENT_DATA_DUMP_REQUEST);
1732
  check_enabled_event (JVMTI_EVENT_MONITOR_WAIT);
1733
  check_enabled_event (JVMTI_EVENT_MONITOR_WAITED);
1734
  check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTER);
1735
  check_enabled_event (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED);
1736
  check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_START);
1737
  check_enabled_event (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH);
1738
  check_enabled_event (JVMTI_EVENT_OBJECT_FREE);
1739
  check_enabled_event (JVMTI_EVENT_VM_OBJECT_ALLOC);
1740
}
1741
 
1742
static jvmtiError JNICALL
1743
_Jv_JVMTI_SetEventNotificationMode (jvmtiEnv *env, jvmtiEventMode mode,
1744
                                    jvmtiEvent type, jthread event_thread, ...)
1745
{
1746
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
1747
 
1748
  if (event_thread != NULL)
1749
    {
1750
      THREAD_CHECK_VALID (event_thread);
1751
      THREAD_CHECK_IS_ALIVE (event_thread);
1752
    }
1753
 
1754
  bool enabled;
1755
  switch (mode)
1756
    {
1757
    case JVMTI_DISABLE:
1758
      enabled = false;
1759
      break;
1760
    case JVMTI_ENABLE:
1761
      enabled = true;
1762
      break;
1763
 
1764
    default:
1765
      return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1766
    }
1767
 
1768
  switch (type)
1769
    {
1770
    case JVMTI_EVENT_VM_INIT:
1771
    case JVMTI_EVENT_VM_DEATH:
1772
    case JVMTI_EVENT_THREAD_START:
1773
    case JVMTI_EVENT_VM_START:
1774
    case JVMTI_EVENT_COMPILED_METHOD_LOAD:
1775
    case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
1776
    case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
1777
    case JVMTI_EVENT_DATA_DUMP_REQUEST:
1778
      ILLEGAL_ARGUMENT (event_thread != NULL);
1779
      break;
1780
 
1781
    case JVMTI_EVENT_THREAD_END:
1782
    case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
1783
    case JVMTI_EVENT_CLASS_LOAD:
1784
    case JVMTI_EVENT_CLASS_PREPARE:
1785
    case JVMTI_EVENT_EXCEPTION:
1786
    case JVMTI_EVENT_EXCEPTION_CATCH:
1787
    case JVMTI_EVENT_SINGLE_STEP:
1788
    case JVMTI_EVENT_FRAME_POP:
1789
    case JVMTI_EVENT_BREAKPOINT:
1790
    case JVMTI_EVENT_FIELD_ACCESS:
1791
    case JVMTI_EVENT_FIELD_MODIFICATION:
1792
    case JVMTI_EVENT_METHOD_ENTRY:
1793
    case JVMTI_EVENT_METHOD_EXIT:
1794
    case JVMTI_EVENT_NATIVE_METHOD_BIND:
1795
    case JVMTI_EVENT_MONITOR_WAIT:
1796
    case JVMTI_EVENT_MONITOR_WAITED:
1797
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
1798
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
1799
    case JVMTI_EVENT_GARBAGE_COLLECTION_START:
1800
    case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
1801
    case JVMTI_EVENT_OBJECT_FREE:
1802
    case JVMTI_EVENT_VM_OBJECT_ALLOC:
1803
      break;
1804
 
1805
    default:
1806
      return JVMTI_ERROR_INVALID_EVENT_TYPE;
1807
    }
1808
 
1809
  env->thread[EVENT_INDEX(type)] = event_thread;
1810
  env->enabled[EVENT_INDEX(type)] = enabled;
1811
  check_enabled_event (type);
1812
  return JVMTI_ERROR_NONE;
1813
}
1814
 
1815
static jvmtiError JNICALL
1816
_Jv_JVMTI_SetEventCallbacks (jvmtiEnv *env,
1817
                             const jvmtiEventCallbacks *callbacks,
1818
                             jint size_of_callbacks)
1819
{
1820
  REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
1821
  ILLEGAL_ARGUMENT (size_of_callbacks < 0);
1822
 
1823
  // Copy the list of callbacks into the environment
1824
  memcpy (&env->callbacks, callbacks, sizeof (jvmtiEventCallbacks));
1825
 
1826
  /* Check which events are now enabeld (JVMTI makes no requirements
1827
     about the order in which SetEventCallbacks and SetEventNotifications
1828
     are called. So we must check all events here. */
1829
  check_enabled_events ();
1830
 
1831
  return JVMTI_ERROR_NONE;
1832
}
1833
 
1834
static jvmtiError JNICALL
1835
_Jv_JVMTI_GetErrorName (MAYBE_UNUSED jvmtiEnv *env, jvmtiError error,
1836
                        char **name_ptr)
1837
{
1838
  NULL_CHECK (name_ptr);
1839
 
1840
  const char *name;
1841
  switch (error)
1842
    {
1843
    case JVMTI_ERROR_NONE:
1844
      name = "none";
1845
      break;
1846
 
1847
    case JVMTI_ERROR_NULL_POINTER:
1848
      name = "null pointer";
1849
      break;
1850
 
1851
    case JVMTI_ERROR_OUT_OF_MEMORY:
1852
      name = "out of memory";
1853
      break;
1854
 
1855
    case JVMTI_ERROR_ACCESS_DENIED:
1856
      name = "access denied";
1857
      break;
1858
 
1859
    case JVMTI_ERROR_WRONG_PHASE:
1860
      name = "wrong phase";
1861
      break;
1862
 
1863
    case JVMTI_ERROR_INTERNAL:
1864
      name = "internal error";
1865
      break;
1866
 
1867
    case JVMTI_ERROR_UNATTACHED_THREAD:
1868
      name = "unattached thread";
1869
      break;
1870
 
1871
    case JVMTI_ERROR_INVALID_ENVIRONMENT:
1872
      name = "invalid environment";
1873
      break;
1874
 
1875
    case JVMTI_ERROR_INVALID_PRIORITY:
1876
      name = "invalid priority";
1877
      break;
1878
 
1879
    case JVMTI_ERROR_THREAD_NOT_SUSPENDED:
1880
      name = "thread not suspended";
1881
      break;
1882
 
1883
    case JVMTI_ERROR_THREAD_SUSPENDED:
1884
      name = "thread suspended";
1885
      break;
1886
 
1887
    case JVMTI_ERROR_THREAD_NOT_ALIVE:
1888
      name = "thread not alive";
1889
      break;
1890
 
1891
    case JVMTI_ERROR_CLASS_NOT_PREPARED:
1892
      name = "class not prepared";
1893
      break;
1894
 
1895
    case JVMTI_ERROR_NO_MORE_FRAMES:
1896
      name = "no more frames";
1897
      break;
1898
 
1899
    case JVMTI_ERROR_OPAQUE_FRAME:
1900
      name = "opaque frame";
1901
      break;
1902
 
1903
    case JVMTI_ERROR_DUPLICATE:
1904
      name = "duplicate";
1905
      break;
1906
 
1907
    case JVMTI_ERROR_NOT_FOUND:
1908
      name = "not found";
1909
      break;
1910
 
1911
    case JVMTI_ERROR_NOT_MONITOR_OWNER:
1912
      name = "not monitor owner";
1913
      break;
1914
 
1915
    case JVMTI_ERROR_INTERRUPT:
1916
      name = "interrupted";
1917
      break;
1918
 
1919
    case JVMTI_ERROR_UNMODIFIABLE_CLASS:
1920
      name = "unmodifiable class";
1921
      break;
1922
 
1923
    case JVMTI_ERROR_NOT_AVAILABLE:
1924
      name = "not available";
1925
      break;
1926
 
1927
    case JVMTI_ERROR_ABSENT_INFORMATION:
1928
      name = "absent information";
1929
      break;
1930
 
1931
    case JVMTI_ERROR_INVALID_EVENT_TYPE:
1932
      name = "invalid event type";
1933
      break;
1934
 
1935
    case JVMTI_ERROR_NATIVE_METHOD:
1936
      name = "native method";
1937
      break;
1938
 
1939
    case JVMTI_ERROR_INVALID_THREAD:
1940
      name = "invalid thread";
1941
      break;
1942
 
1943
    case JVMTI_ERROR_INVALID_THREAD_GROUP:
1944
      name = "invalid thread group";
1945
      break;
1946
 
1947
    case JVMTI_ERROR_INVALID_OBJECT:
1948
      name = "invalid object";
1949
      break;
1950
 
1951
    case JVMTI_ERROR_INVALID_CLASS:
1952
      name = "invalid class";
1953
      break;
1954
 
1955
    case JVMTI_ERROR_INVALID_METHODID:
1956
      name = "invalid method ID";
1957
      break;
1958
 
1959
    case JVMTI_ERROR_INVALID_LOCATION:
1960
      name = "invalid location";
1961
      break;
1962
 
1963
    case JVMTI_ERROR_INVALID_FIELDID:
1964
      name = "invalid field ID";
1965
      break;
1966
 
1967
    case JVMTI_ERROR_TYPE_MISMATCH:
1968
      name = "type mismatch";
1969
      break;
1970
 
1971
    case JVMTI_ERROR_INVALID_SLOT:
1972
      name = "invalid slot";
1973
      break;
1974
 
1975
    case JVMTI_ERROR_INVALID_MONITOR:
1976
      name = "invalid monitor";
1977
      break;
1978
 
1979
    case JVMTI_ERROR_INVALID_CLASS_FORMAT:
1980
      name = "invalid class format";
1981
      break;
1982
 
1983
    case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION:
1984
      name = "circular class definition";
1985
      break;
1986
 
1987
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED:
1988
      name = "unsupported redefinition: method added";
1989
      break;
1990
 
1991
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED:
1992
      name = "unsupported redefinition: schema changed";
1993
      break;
1994
 
1995
    case JVMTI_ERROR_INVALID_TYPESTATE:
1996
      name = "invalid type state";
1997
      break;
1998
 
1999
    case JVMTI_ERROR_FAILS_VERIFICATION:
2000
      name = "fails verification";
2001
      break;
2002
 
2003
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED:
2004
      name = "unsupported redefinition: hierarchy changed";
2005
      break;
2006
 
2007
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED:
2008
      name = "unsupported redefinition: method deleted";
2009
      break;
2010
 
2011
    case JVMTI_ERROR_UNSUPPORTED_VERSION:
2012
      name = "unsupported version";
2013
      break;
2014
 
2015
    case JVMTI_ERROR_NAMES_DONT_MATCH:
2016
      name = "names do not match";
2017
      break;
2018
 
2019
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED:
2020
      name = "unsupported redefinition: class modifiers changed";
2021
      break;
2022
 
2023
    case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED:
2024
      name = "unsupported redefinition: method modifiers changed";
2025
      break;
2026
 
2027
    case JVMTI_ERROR_MUST_POSSESS_CAPABILITY:
2028
      name = "must possess capability";
2029
      break;
2030
 
2031
    case JVMTI_ERROR_ILLEGAL_ARGUMENT:
2032
      name = "illegal argument";
2033
      break;
2034
 
2035
    default:
2036
      return JVMTI_ERROR_ILLEGAL_ARGUMENT;
2037
    }
2038
 
2039
  *name_ptr = (char *) _Jv_MallocUnchecked (strlen (name) + 1);
2040
  if (*name_ptr == NULL)
2041
    return JVMTI_ERROR_OUT_OF_MEMORY;
2042
 
2043
  strcpy (*name_ptr, name);
2044
  return JVMTI_ERROR_NONE;
2045
}
2046
 
2047
#define RESERVED NULL
2048
#define UNIMPLEMENTED NULL
2049
 
2050
struct _Jv_jvmtiEnv _Jv_JVMTI_Interface =
2051
{
2052
  RESERVED,                     // reserved1
2053
  _Jv_JVMTI_SetEventNotificationMode, // SetEventNotificationMode
2054
  RESERVED,                     // reserved3
2055
  _Jv_JVMTI_GetAllThreads,              // GetAllThreads
2056
  _Jv_JVMTI_SuspendThread,      // SuspendThread
2057
  _Jv_JVMTI_ResumeThread,       // ResumeThread
2058
  UNIMPLEMENTED,                // StopThread
2059
  _Jv_JVMTI_InterruptThread,    // InterruptThread
2060
  UNIMPLEMENTED,                // GetThreadInfo
2061
  UNIMPLEMENTED,                // GetOwnedMonitorInfo
2062
  UNIMPLEMENTED,                // GetCurrentContendedMonitor
2063
  UNIMPLEMENTED,                // RunAgentThread
2064
  UNIMPLEMENTED,                // GetTopThreadGroups
2065
  UNIMPLEMENTED,                // GetThreadGroupInfo
2066
  UNIMPLEMENTED,                // GetThreadGroupChildren
2067
  _Jv_JVMTI_GetFrameCount,              // GetFrameCount
2068
  _Jv_JVMTI_GetThreadState,     // GetThreadState
2069
  RESERVED,                     // reserved18
2070
  UNIMPLEMENTED,                // GetFrameLocation
2071
  UNIMPLEMENTED,                // NotifyPopFrame
2072
  _Jv_JVMTI_GetLocalObject,             // GetLocalObject
2073
  _Jv_JVMTI_GetLocalInt,                // GetLocalInt
2074
  _Jv_JVMTI_GetLocalLong,               // GetLocalLong
2075
  _Jv_JVMTI_GetLocalFloat,              // GetLocalFloat
2076
  _Jv_JVMTI_GetLocalDouble,             // GetLocalDouble
2077
  _Jv_JVMTI_SetLocalObject,             // SetLocalObject
2078
  _Jv_JVMTI_SetLocalInt,                // SetLocalInt
2079
  _Jv_JVMTI_SetLocalLong,               // SetLocalLong
2080
  _Jv_JVMTI_SetLocalFloat,              // SetLocalFloat
2081
  _Jv_JVMTI_SetLocalDouble,             // SetLocalDouble
2082
  _Jv_JVMTI_CreateRawMonitor,   // CreateRawMonitor
2083
  _Jv_JVMTI_DestroyRawMonitor,  // DestroyRawMonitor
2084
  _Jv_JVMTI_RawMonitorEnter,    // RawMonitorEnter
2085
  _Jv_JVMTI_RawMonitorExit,     // RawMonitorExit
2086
  _Jv_JVMTI_RawMonitorWait,     // RawMonitorWait
2087
  _Jv_JVMTI_RawMonitorNotify,   // RawMonitorNotify
2088
  _Jv_JVMTI_RawMonitorNotifyAll, // RawMonitorNotifyAll
2089
  _Jv_JVMTI_SetBreakpoint,      // SetBreakpoint
2090
  _Jv_JVMTI_ClearBreakpoint,    // ClearBreakpoint
2091
  RESERVED,                     // reserved40
2092
  UNIMPLEMENTED,                // SetFieldAccessWatch
2093
  UNIMPLEMENTED,                // ClearFieldAccessWatch
2094
  UNIMPLEMENTED,                // SetFieldModificationWatch
2095
  UNIMPLEMENTED,                // ClearFieldModificationWatch
2096
  RESERVED,                     // reserved45
2097
  _Jv_JVMTI_Allocate,           // Allocate
2098
  _Jv_JVMTI_Deallocate,         // Deallocate
2099
  UNIMPLEMENTED,                // GetClassSignature
2100
  _Jv_JVMTI_GetClassStatus,     // GetClassStatus
2101
  UNIMPLEMENTED,                // GetSourceFileName
2102
  _Jv_JVMTI_GetClassModifiers,  // GetClassModifiers
2103
  _Jv_JVMTI_GetClassMethods,    // GetClassMethods
2104
  UNIMPLEMENTED,                // GetClassFields
2105
  UNIMPLEMENTED,                // GetImplementedInterfaces
2106
  _Jv_JVMTI_IsInterface,        // IsInterface
2107
  _Jv_JVMTI_IsArrayClass,       // IsArrayClass
2108
  _Jv_JVMTI_GetClassLoader,     // GetClassLoader
2109
  _Jv_JVMTI_GetObjectHashCode,  // GetObjectHashCode
2110
  UNIMPLEMENTED,                // GetObjectMonitorUsage
2111
  UNIMPLEMENTED,                // GetFieldName
2112
  UNIMPLEMENTED,                // GetFieldDeclaringClass
2113
  _Jv_JVMTI_GetFieldModifiers,  // GetFieldModifiers
2114
  _Jv_JVMTI_IsFieldSynthetic,   // IsFieldSynthetic
2115
  _Jv_JVMTI_GetMethodName,      // GetMethodName
2116
  _Jv_JVMTI_GetMethodDeclaringClass,  // GetMethodDeclaringClass
2117
  _Jv_JVMTI_GetMethodModifiers, // GetMethodModifers
2118
  RESERVED,                     // reserved67
2119
  _Jv_JVMTI_GetMaxLocals,               // GetMaxLocals
2120
  _Jv_JVMTI_GetArgumentsSize,           // GetArgumentsSize
2121
  _Jv_JVMTI_GetLineNumberTable, // GetLineNumberTable
2122
  UNIMPLEMENTED,                // GetMethodLocation
2123
  _Jv_JVMTI_GetLocalVariableTable,              // GetLocalVariableTable
2124
  RESERVED,                     // reserved73
2125
  RESERVED,                     // reserved74
2126
  UNIMPLEMENTED,                // GetBytecodes
2127
  _Jv_JVMTI_IsMethodNative,     // IsMethodNative
2128
  _Jv_JVMTI_IsMethodSynthetic,  // IsMethodSynthetic
2129
  UNIMPLEMENTED,                // GetLoadedClasses
2130
  _Jv_JVMTI_GetClassLoaderClasses, // GetClassLoaderClasses
2131
  UNIMPLEMENTED,                // PopFrame
2132
  RESERVED,                     // reserved81
2133
  RESERVED,                     // reserved82
2134
  RESERVED,                     // reserved83
2135
  RESERVED,                     // reserved84
2136
  RESERVED,                     // reserved85
2137
  RESERVED,                     // reserved86
2138
  UNIMPLEMENTED,                // RedefineClasses
2139
  UNIMPLEMENTED,                // GetVersionNumber
2140
  UNIMPLEMENTED,                // GetCapabilities
2141
  UNIMPLEMENTED,                // GetSourceDebugExtension
2142
  UNIMPLEMENTED,                // IsMethodObsolete
2143
  UNIMPLEMENTED,                // SuspendThreadList
2144
  UNIMPLEMENTED,                // ResumeThreadList
2145
  RESERVED,                     // reserved94
2146
  RESERVED,                     // reserved95
2147
  RESERVED,                     // reserved96
2148
  RESERVED,                     // reserved97
2149
  RESERVED,                     // reserved98
2150
  RESERVED,                     // reserved99
2151
  UNIMPLEMENTED,                // GetAllStackTraces
2152
  UNIMPLEMENTED,                // GetThreadListStackTraces
2153
  UNIMPLEMENTED,                // GetThreadLocalStorage
2154
  UNIMPLEMENTED,                // SetThreadLocalStorage
2155
  _Jv_JVMTI_GetStackTrace,              // GetStackTrace
2156
  RESERVED,                     // reserved105
2157
  UNIMPLEMENTED,                // GetTag
2158
  UNIMPLEMENTED,                // SetTag
2159
  _Jv_JVMTI_ForceGarbageCollection, // ForceGarbageCollection
2160
  UNIMPLEMENTED,                // IterateOverObjectsReachable
2161
  UNIMPLEMENTED,                // IterateOverReachableObjects
2162
  UNIMPLEMENTED,                // IterateOverHeap
2163
  UNIMPLEMENTED,                // IterateOverInstanceOfClass
2164
  RESERVED,                     // reserved113
2165
  UNIMPLEMENTED,                // GetObjectsWithTags
2166
  RESERVED,                     // reserved115
2167
  RESERVED,                     // reserved116
2168
  RESERVED,                     // reserved117
2169
  RESERVED,                     // reserved118
2170
  RESERVED,                     // reserved119
2171
  _Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable
2172
  _Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable
2173
  _Jv_JVMTI_SetEventCallbacks,  // SetEventCallbacks
2174
  UNIMPLEMENTED,                // GenerateEvents
2175
  UNIMPLEMENTED,                // GetExtensionFunctions
2176
  UNIMPLEMENTED,                // GetExtensionEvents
2177
  UNIMPLEMENTED,                // SetExtensionEventCallback
2178
  _Jv_JVMTI_DisposeEnvironment, // DisposeEnvironment
2179
  _Jv_JVMTI_GetErrorName,       // GetErrorName
2180
  UNIMPLEMENTED,                // GetJLocationFormat
2181
  UNIMPLEMENTED,                // GetSystemProperties
2182
  _Jv_JVMTI_GetSystemProperty,  // GetSystemProperty
2183
  _Jv_JVMTI_SetSystemProperty,  // SetSystemProperty
2184
  UNIMPLEMENTED,                // GetPhase
2185
  UNIMPLEMENTED,                // GetCurrentThreadCpuTimerInfo
2186
  UNIMPLEMENTED,                // GetCurrentThreadCpuTime
2187
  UNIMPLEMENTED,                // GetThreadCpuTimerInfo
2188
  UNIMPLEMENTED,                // GetThreadCpuTime
2189
  UNIMPLEMENTED,                // GetTimerInfo
2190
  _Jv_JVMTI_GetTime,            // GetTime
2191
  UNIMPLEMENTED,                // GetPotentialCapabilities
2192
  RESERVED,                     // reserved141
2193
  UNIMPLEMENTED,                // AddCapabilities
2194
  UNIMPLEMENTED,                // RelinquishCapabilities
2195
  _Jv_JVMTI_GetAvailableProcessors, // GetAvailableProcessors
2196
  RESERVED,                     // reserved145
2197
  RESERVED,                     // reserved146
2198
  UNIMPLEMENTED,                // GetEnvironmentLocalStorage
2199
  UNIMPLEMENTED,                // SetEnvironmentLocalStorage
2200
  _Jv_JVMTI_AddToBootstrapClassLoaderSearch, // AddToBootstrapClassLoaderSearch
2201
  _Jv_JVMTI_SetVerboseFlag,     // SetVerboseFlag
2202
  RESERVED,                     // reserved151
2203
  RESERVED,                     // reserved152
2204
  RESERVED,                     // reserved153
2205
  _Jv_JVMTI_GetObjectSize       // GetObjectSize
2206
};
2207
 
2208
_Jv_JVMTIEnv *
2209
_Jv_GetJVMTIEnv (void)
2210
{
2211
  _Jv_JVMTIEnv *env
2212
    = (_Jv_JVMTIEnv *) _Jv_MallocUnchecked (sizeof (_Jv_JVMTIEnv));
2213
  memset (env, 0, sizeof (_Jv_JVMTIEnv));
2214
  env->p = &_Jv_JVMTI_Interface;
2215
  struct jvmti_env_list *element
2216
    = (struct jvmti_env_list *) _Jv_MallocUnchecked (sizeof (struct jvmti_env_list));
2217
  element->env = env;
2218
  element->next = NULL;
2219
 
2220
  _envListLock->writeLock ()->lock ();
2221
  if (_jvmtiEnvironments == NULL)
2222
    _jvmtiEnvironments = element;
2223
  else
2224
    {
2225
      struct jvmti_env_list *e;
2226
      for (e = _jvmtiEnvironments; e->next != NULL; e = e->next)
2227
        ;
2228
      e->next = element;
2229
    }
2230
  _envListLock->writeLock ()->unlock ();
2231
 
2232
  /* Mark JVMTI active. This is used to force the interpreter
2233
     to use either debugging or non-debugging code. Once JVMTI
2234
     has been enabled, the non-debug interpreter cannot be used. */
2235
  JVMTI::enabled = true;
2236
  return env;
2237
}
2238
 
2239
void
2240
_Jv_JVMTI_Init ()
2241
{
2242
  _jvmtiEnvironments = NULL;
2243
  _envListLock
2244
    = new java::util::concurrent::locks::ReentrantReadWriteLock ();
2245
 
2246
  // No environments, so this should set all JVMTI:: members to false
2247
  check_enabled_events ();
2248
}
2249
 
2250
static void
2251
post_event (jvmtiEnv *env, jvmtiEvent type, jthread event_thread, va_list args)
2252
{
2253
#define ARG(Type,Name) Type Name = (Type) va_arg (args, Type)
2254
 
2255
#define GET_BOOLEAN_ARG(Name)                   \
2256
  ARG (int, b);                                 \
2257
  jboolean Name = (b == 0) ? false : true
2258
 
2259
#define GET_CHAR_ARG(Name)                      \
2260
  ARG (int, c);                                 \
2261
  char Name = static_cast<char> (c)
2262
 
2263
  switch (type)
2264
    {
2265
    case JVMTI_EVENT_VM_INIT:
2266
      if (env->callbacks.VMInit != NULL)
2267
        {
2268
          ARG (JNIEnv *, jni_env);
2269
          env->callbacks.VMInit (env, jni_env, event_thread);
2270
        }
2271
      break;
2272
 
2273
    case JVMTI_EVENT_VM_DEATH:
2274
      if (env->callbacks.VMDeath != NULL)
2275
        {
2276
          ARG (JNIEnv *, jni_env);
2277
          env->callbacks.VMDeath (env, jni_env);
2278
        }
2279
      break;
2280
 
2281
    case JVMTI_EVENT_THREAD_START:
2282
      if (env->callbacks.ThreadStart != NULL)
2283
        {
2284
          ARG (JNIEnv *, jni_env);
2285
          env->callbacks.ThreadStart (env, jni_env, event_thread);
2286
        }
2287
      break;
2288
 
2289
    case JVMTI_EVENT_THREAD_END:
2290
      if (env->callbacks.ThreadEnd != NULL)
2291
        {
2292
          ARG (JNIEnv *, jni_env);
2293
          env->callbacks.ThreadEnd (env, jni_env, event_thread);
2294
        }
2295
      break;
2296
 
2297
    case JVMTI_EVENT_CLASS_FILE_LOAD_HOOK:
2298
      if (env->callbacks.ClassFileLoadHook != NULL)
2299
        {
2300
          ARG (JNIEnv *, jni_env);
2301
          ARG (jclass, class_being_redefined);
2302
          ARG (jobject, loader);
2303
          ARG (const char *, name);
2304
          ARG (jobject, protection_domain);
2305
          ARG (jint, class_data_len);
2306
          ARG (const unsigned char *, class_data);
2307
          ARG (jint *, new_class_data_len);
2308
          ARG (unsigned char **, new_class_data);
2309
          env->callbacks.ClassFileLoadHook (env, jni_env,
2310
                                            class_being_redefined, loader,
2311
                                            name, protection_domain,
2312
                                            class_data_len, class_data,
2313
                                            new_class_data_len,
2314
                                            new_class_data);
2315
        }
2316
      break;
2317
 
2318
    case JVMTI_EVENT_CLASS_LOAD:
2319
      if (env->callbacks.ClassLoad != NULL)
2320
        {
2321
          ARG (JNIEnv *, jni_env);
2322
          ARG (jclass, klass);
2323
          env->callbacks.ClassLoad (env, jni_env, event_thread, klass);
2324
        }
2325
      break;
2326
 
2327
    case JVMTI_EVENT_CLASS_PREPARE:
2328
      if (env->callbacks.ClassPrepare != NULL)
2329
        {
2330
          ARG (JNIEnv *, jni_env);
2331
          ARG (jclass, klass);
2332
          env->callbacks.ClassPrepare (env, jni_env, event_thread, klass);
2333
        }
2334
      break;
2335
 
2336
    case JVMTI_EVENT_VM_START:
2337
      if (env->callbacks.VMStart != NULL)
2338
        {
2339
          ARG (JNIEnv *, jni_env);
2340
          env->callbacks.VMStart (env, jni_env);
2341
        }
2342
      break;
2343
 
2344
    case JVMTI_EVENT_EXCEPTION:
2345
      if (env->callbacks.Exception != NULL)
2346
        {
2347
          ARG (JNIEnv *, jni_env);
2348
          ARG (jmethodID, method);
2349
          ARG (jlocation, location);
2350
          ARG (jobject, exception);
2351
          ARG (jmethodID, catch_method);
2352
          ARG (jlocation, catch_location);
2353
          env->callbacks.Exception (env, jni_env, event_thread, method,
2354
                                    location, exception, catch_method,
2355
                                    catch_location);
2356
        }
2357
      break;
2358
 
2359
    case JVMTI_EVENT_EXCEPTION_CATCH:
2360
      if (env->callbacks.ExceptionCatch != NULL)
2361
        {
2362
          ARG (JNIEnv *, jni_env);
2363
          ARG (jmethodID, method);
2364
          ARG (jlocation, location);
2365
          ARG (jobject, exception);
2366
          env->callbacks.ExceptionCatch (env, jni_env, event_thread, method,
2367
                                         location, exception);
2368
        }
2369
      break;
2370
 
2371
    case JVMTI_EVENT_SINGLE_STEP:
2372
      if (env->callbacks.SingleStep != NULL)
2373
        {
2374
          ARG (JNIEnv *, jni_env);
2375
          ARG (jmethodID, method);
2376
          ARG (jlocation, location);
2377
          env->callbacks.SingleStep (env, jni_env, event_thread, method,
2378
                                     location);
2379
        }
2380
      break;
2381
 
2382
    case JVMTI_EVENT_FRAME_POP:
2383
      if (env->callbacks.FramePop != NULL)
2384
        {
2385
          ARG (JNIEnv *, jni_env);
2386
          ARG (jmethodID, method);
2387
          GET_BOOLEAN_ARG (was_popped_by_exception);
2388
          env->callbacks.FramePop (env, jni_env, event_thread, method,
2389
                                   was_popped_by_exception);
2390
        }
2391
      break;
2392
 
2393
    case JVMTI_EVENT_BREAKPOINT:
2394
      if (env->callbacks.Breakpoint != NULL)
2395
        {
2396
          ARG (JNIEnv *, jni_env);
2397
          ARG (jmethodID, method);
2398
          ARG (jlocation, location);
2399
          env->callbacks.Breakpoint (env, jni_env, event_thread, method,
2400
                                     location);
2401
        }
2402
      break;
2403
 
2404
    case JVMTI_EVENT_FIELD_ACCESS:
2405
      if (env->callbacks.FieldAccess != NULL)
2406
        {
2407
          ARG (JNIEnv *, jni_env);
2408
          ARG (jmethodID, method);
2409
          ARG (jlocation, location);
2410
          ARG (jclass, field_class);
2411
          ARG (jobject, object);
2412
          ARG (jfieldID, field);
2413
          env->callbacks.FieldAccess (env, jni_env, event_thread, method,
2414
                                      location, field_class, object, field);
2415
        }
2416
      break;
2417
 
2418
    case JVMTI_EVENT_FIELD_MODIFICATION:
2419
      if (env->callbacks.FieldModification != NULL)
2420
        {
2421
          ARG (JNIEnv *, jni_env);
2422
          ARG (jmethodID, method);
2423
          ARG (jlocation, location);
2424
          ARG (jclass, field_class);
2425
          ARG (jobject, object);
2426
          ARG (jfieldID, field);
2427
          GET_CHAR_ARG (signature_type);
2428
          ARG (jvalue, new_value);
2429
          env->callbacks.FieldModification (env, jni_env, event_thread, method,
2430
                                            location, field_class, object,
2431
                                            field, signature_type, new_value);
2432
        }
2433
      break;
2434
 
2435
    case JVMTI_EVENT_METHOD_ENTRY:
2436
      if (env->callbacks.MethodEntry != NULL)
2437
        {
2438
          ARG (JNIEnv *, jni_env);
2439
          ARG (jmethodID, method);
2440
          env->callbacks.MethodEntry (env, jni_env, event_thread, method);
2441
        }
2442
      break;
2443
 
2444
    case JVMTI_EVENT_METHOD_EXIT:
2445
      if (env->callbacks.MethodExit != NULL)
2446
        {
2447
          ARG (JNIEnv *, jni_env);
2448
          ARG (jmethodID, method);
2449
          GET_BOOLEAN_ARG (was_popped_by_exception);
2450
          ARG (jvalue, return_value);
2451
          env->callbacks.MethodExit (env, jni_env, event_thread, method,
2452
                                     was_popped_by_exception, return_value);
2453
        }
2454
      break;
2455
 
2456
    case JVMTI_EVENT_NATIVE_METHOD_BIND:
2457
      if (env->callbacks.NativeMethodBind != NULL)
2458
        {
2459
          ARG (JNIEnv *, jni_env);
2460
          ARG (jmethodID, method);
2461
          ARG (void *, address);
2462
          ARG (void **, new_address_ptr);
2463
          env->callbacks.NativeMethodBind (env, jni_env, event_thread, method,
2464
                                           address, new_address_ptr);
2465
        }
2466
      break;
2467
 
2468
    case JVMTI_EVENT_COMPILED_METHOD_LOAD:
2469
      if (env->callbacks.CompiledMethodLoad != NULL)
2470
        {
2471
          ARG (jmethodID, method);
2472
          ARG (jint, code_size);
2473
          ARG (const void *, code_addr);
2474
          ARG (jint, map_length);
2475
          ARG (const jvmtiAddrLocationMap *, map);
2476
          ARG (const void *, compile_info);
2477
          env->callbacks.CompiledMethodLoad (env, method, code_size, code_addr,
2478
                                             map_length, map, compile_info);
2479
        }
2480
      break;
2481
 
2482
    case JVMTI_EVENT_COMPILED_METHOD_UNLOAD:
2483
      if (env->callbacks.CompiledMethodUnload != NULL)
2484
        {
2485
          ARG (jmethodID, method);
2486
          ARG (const void *, code_addr);
2487
          env->callbacks.CompiledMethodUnload (env, method, code_addr);
2488
        }
2489
      break;
2490
 
2491
    case JVMTI_EVENT_DYNAMIC_CODE_GENERATED:
2492
      if (env->callbacks.DynamicCodeGenerated != NULL)
2493
        {
2494
          ARG (const char *, name);
2495
          ARG (const void *, address);
2496
          ARG (jint, length);
2497
          env->callbacks.DynamicCodeGenerated (env, name, address, length);
2498
        }
2499
      break;
2500
 
2501
    case JVMTI_EVENT_DATA_DUMP_REQUEST:
2502
      if (env->callbacks.DataDumpRequest != NULL)
2503
        {
2504
          env->callbacks.DataDumpRequest (env);
2505
        }
2506
      break;
2507
 
2508
    case JVMTI_EVENT_MONITOR_WAIT:
2509
      if (env->callbacks.MonitorWait != NULL)
2510
        {
2511
          ARG (JNIEnv *, jni_env);
2512
          ARG (jobject, object);
2513
          ARG (jlong, timeout);
2514
          env->callbacks.MonitorWait (env, jni_env, event_thread, object,
2515
                                      timeout);
2516
        }
2517
      break;
2518
 
2519
    case JVMTI_EVENT_MONITOR_WAITED:
2520
      if (env->callbacks.MonitorWaited != NULL)
2521
        {
2522
          ARG (JNIEnv *, jni_env);
2523
          ARG (jobject, object);
2524
          GET_BOOLEAN_ARG (timed_out);
2525
          env->callbacks.MonitorWaited (env, jni_env, event_thread, object,
2526
                                        timed_out);
2527
        }
2528
      break;
2529
 
2530
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
2531
      if (env->callbacks.MonitorContendedEnter != NULL)
2532
        {
2533
          ARG (JNIEnv *, jni_env);
2534
          ARG (jobject, object);
2535
          env->callbacks.MonitorContendedEnter (env, jni_env, event_thread,
2536
                                                object);
2537
        }
2538
      break;
2539
 
2540
    case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
2541
      if (env->callbacks.MonitorContendedEntered != NULL)
2542
        {
2543
          ARG (JNIEnv *, jni_env);
2544
          ARG (jobject, object);
2545
          env->callbacks.MonitorContendedEntered (env, jni_env, event_thread,
2546
                                                  object);
2547
        }
2548
      break;
2549
 
2550
    case JVMTI_EVENT_GARBAGE_COLLECTION_START:
2551
      if (env->callbacks.GarbageCollectionStart != NULL)
2552
        {
2553
          env->callbacks.GarbageCollectionStart (env);
2554
        }
2555
      break;
2556
 
2557
    case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
2558
      if (env->callbacks.GarbageCollectionFinish != NULL)
2559
        {
2560
          env->callbacks.GarbageCollectionFinish (env);
2561
        }
2562
      break;
2563
 
2564
    case JVMTI_EVENT_OBJECT_FREE:
2565
      if (env->callbacks.ObjectFree != NULL)
2566
        {
2567
          ARG (jlong, tag);
2568
          env->callbacks.ObjectFree (env, tag);
2569
        }
2570
      break;
2571
 
2572
    case JVMTI_EVENT_VM_OBJECT_ALLOC:
2573
      if (env->callbacks.VMObjectAlloc != NULL)
2574
        {
2575
          ARG (JNIEnv *, jni_env);
2576
          ARG (jobject, object);
2577
          ARG (jclass, object_class);
2578
          ARG (jlong, size);
2579
          env->callbacks.VMObjectAlloc (env, jni_env, event_thread,
2580
                                        object, object_class, size);
2581
        }
2582
      break;
2583
 
2584
    default:
2585
      fprintf (stderr, "libgcj: post of unknown JVMTI event (%d)\n",
2586
               (int) type);
2587
      break;
2588
    }
2589
  va_end (args);
2590
#undef ARG
2591
#undef GET_BOOLEAN_ARG
2592
#undef GET_CHAR_ARG
2593
}
2594
 
2595
/* Post an event to requesting JVMTI environments
2596
 *
2597
 * This function should not be called without consulting the
2598
 * JVMTI_REQUESTED_EVENT macro first (for speed). It does no real
2599
 * harm (other than kill speed), since this function will still
2600
 * only send the event if it was properly requested by an environment.
2601
 */
2602
void
2603
_Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...)
2604
{
2605
  va_list args;
2606
  va_start (args, event_thread);
2607
 
2608
  _envListLock->readLock ()->lock ();
2609
  struct jvmti_env_list *e;
2610
  FOREACH_ENVIRONMENT (e)
2611
    {
2612
      /* Events are only posted if the event was explicitly enabled,
2613
         it has a registered event handler, and the event thread
2614
         matches (either globally or restricted to a specific thread).
2615
         Here we check all but the event handler, which will be handled
2616
         by post_event. */
2617
      if (e->env->enabled[EVENT_INDEX(type)]
2618
          && (e->env->thread[EVENT_INDEX(type)] == NULL
2619
              || e->env->thread[EVENT_INDEX(type)] == event_thread))
2620
        {
2621
          post_event (e->env, type, event_thread, args);
2622
        }
2623
    }
2624
  _envListLock->readLock ()->unlock ();
2625
  va_end (args);
2626
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.