libjava/jvmti.cc

   1 // jvmti.cc - JVMTI implementation
   2
   3 /* Copyright (C) 2006 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 <jvmti.h>
  18
  19 #include <gnu/classpath/SystemProperties.h>
  20 #include <gnu/gcj/runtime/BootClassLoader.h>
  21 #include <java/lang/Class.h>
  22 #include <java/lang/ClassLoader.h>
  23 #include <java/lang/Thread.h>
  24 #include <java/lang/Throwable.h>
  25 #include <java/lang/VMClassLoader.h>
  26 #include <java/lang/reflect/Field.h>
  27 #include <java/lang/reflect/Modifier.h>
  28 #include <java/util/Collection.h>
  29 #include <java/util/HashMap.h>
  30 #include <java/net/URL.h>
  31
  32 extern struct JNINativeInterface _Jv_JNIFunctions;
  33
  34 struct _Jv_rawMonitorID
  35 {
  36   _Jv_Mutex_t mutex;
  37   _Jv_ConditionVariable_t condition;
  38 };
  39
  40 // Some commonly-used checks
  41
  42 #define THREAD_DEFAULT_TO_CURRENT(jthread)                              \
  43   if (jthread == NULL) jthread = java::lang::Thread::currentThread ();
  44
  45 #define THREAD_CHECK_VALID(jthread)                                     \
  46   if (!java::lang::Thread::class$.isAssignableFrom (&(jthread->class$))) \
  47     return JVMTI_ERROR_INVALID_THREAD;
  48
  49 #define THREAD_CHECK_IS_ALIVE(thread)                           \
  50   if (!thread->isAlive ()) return JVMTI_ERROR_THREAD_NOT_ALIVE;
  51
  52 // FIXME: if current phase is not set in Phases,
  53 // return JVMTI_ERROR_WRONG_PHASE
  54 #define REQUIRE_PHASE(Env, Phases)
  55
  56 #define NULL_CHECK(Ptr)                                 \
  57   if (Ptr == NULL) return JVMTI_ERROR_NULL_POINTER;
  58
  59 static jvmtiError JNICALL
  60 _Jv_JVMTI_SuspendThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
  61 {
  62   using namespace java::lang;
  63
  64   THREAD_DEFAULT_TO_CURRENT (thread);
  65   THREAD_CHECK_VALID (thread);
  66
  67   Thread *t = reinterpret_cast<Thread *> (thread);
  68   THREAD_CHECK_IS_ALIVE (t);
  69
  70   _Jv_Thread_t *data = _Jv_ThreadGetData (t);
  71   _Jv_SuspendThread (data);
  72   return JVMTI_ERROR_NONE;
  73 }
  74
  75 static jvmtiError JNICALL
  76 _Jv_JVMTI_ResumeThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
  77 {
  78   using namespace java::lang;
  79
  80   THREAD_DEFAULT_TO_CURRENT (thread);
  81   THREAD_CHECK_VALID (thread);
  82
  83   Thread *t = reinterpret_cast<Thread *> (thread);
  84   THREAD_CHECK_IS_ALIVE (t);
  85
  86   _Jv_Thread_t *data = _Jv_ThreadGetData (t);
  87   _Jv_ResumeThread (data);
  88   return JVMTI_ERROR_NONE;
  89 }
  90
  91 static jvmtiError JNICALL
  92 _Jv_JVMTI_InterruptThread (MAYBE_UNUSED jvmtiEnv *env, jthread thread)
  93 {
  94   using namespace java::lang;
  95
  96   REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
  97   // FIXME: capability handling?  'can_signal_thread'
  98   if (thread == NULL)
  99     return JVMTI_ERROR_INVALID_THREAD;
 100   THREAD_CHECK_VALID (thread);
 101   Thread *real_thread = reinterpret_cast<Thread *> (thread);
 102   THREAD_CHECK_IS_ALIVE (real_thread);
 103   real_thread->interrupt();
 104   return JVMTI_ERROR_NONE;
 105 }
 106
 107 static jvmtiError JNICALL
 108 _Jv_JVMTI_CreateRawMonitor (MAYBE_UNUSED jvmtiEnv *env, const char *name,
 109                             jrawMonitorID *result)
 110 {
 111   REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
 112   NULL_CHECK (name);
 113   NULL_CHECK (result);
 114   *result = (jrawMonitorID) _Jv_Malloc (sizeof (_Jv_rawMonitorID));
 115   _Jv_MutexInit (&(*result)->mutex);
 116   _Jv_CondInit (&(*result)->condition);
 117   return JVMTI_ERROR_NONE;
 118 }
 119
 120 static jvmtiError JNICALL
 121 _Jv_JVMTI_DestroyRawMonitor (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
 122 {
 123   REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
 124   // Note we have no better way of knowing whether this object is
 125   // really a raw monitor.
 126   if (monitor == NULL)
 127     return JVMTI_ERROR_INVALID_MONITOR;
 128   // FIXME: perform checks on monitor, release it if this thread owns
 129   // it.
 130 #ifdef _Jv_HaveMutexDestroy
 131   _Jv_MutexDestroy (&monitor->mutex);
 132 #endif
 133   _Jv_Free (monitor);
 134   return JVMTI_ERROR_NONE;
 135 }
 136
 137 static jvmtiError JNICALL
 138 _Jv_JVMTI_RawMonitorEnter (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
 139 {
 140   if (monitor == NULL)
 141     return JVMTI_ERROR_INVALID_MONITOR;
 142   _Jv_MutexLock (&monitor->mutex);
 143   return JVMTI_ERROR_NONE;
 144 }
 145
 146 static jvmtiError JNICALL
 147 _Jv_JVMTI_RawMonitorExit (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
 148 {
 149   if (monitor == NULL)
 150     return JVMTI_ERROR_INVALID_MONITOR;
 151   if (_Jv_MutexUnlock (&monitor->mutex))
 152     return JVMTI_ERROR_NOT_MONITOR_OWNER;
 153   return JVMTI_ERROR_NONE;
 154 }
 155
 156 static jvmtiError JNICALL
 157 _Jv_JVMTI_RawMonitorWait (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
 158 {
 159   if (monitor == NULL)
 160     return JVMTI_ERROR_INVALID_MONITOR;
 161   int r = _Jv_CondWait (&monitor->condition, &monitor->mutex, 0, 0);
 162   if (r == _JV_NOT_OWNER)
 163     return JVMTI_ERROR_NOT_MONITOR_OWNER;
 164   if (r == _JV_INTERRUPTED)
 165     return JVMTI_ERROR_INTERRUPT;
 166   return JVMTI_ERROR_NONE;
 167 }
 168
 169 static jvmtiError JNICALL
 170 _Jv_JVMTI_RawMonitorNotify (MAYBE_UNUSED jvmtiEnv *env, jrawMonitorID monitor)
 171 {
 172   if (monitor == NULL)
 173     return JVMTI_ERROR_INVALID_MONITOR;
 174   if (_Jv_CondNotify (&monitor->condition, &monitor->mutex) == _JV_NOT_OWNER)
 175     return JVMTI_ERROR_NOT_MONITOR_OWNER;
 176   return JVMTI_ERROR_NONE;
 177 }
 178
 179 static jvmtiError JNICALL
 180 _Jv_JVMTI_RawMonitorNotifyAll (MAYBE_UNUSED jvmtiEnv *env,
 181                                jrawMonitorID monitor)
 182 {
 183   if (monitor == NULL)
 184     return JVMTI_ERROR_INVALID_MONITOR;
 185   if (_Jv_CondNotifyAll (&monitor->condition, &monitor->mutex)
 186       == _JV_NOT_OWNER)
 187     return JVMTI_ERROR_NOT_MONITOR_OWNER;
 188   return JVMTI_ERROR_NONE;
 189 }
 190
 191 static jvmtiError JNICALL
 192 _Jv_JVMTI_Allocate (MAYBE_UNUSED jvmtiEnv *env, jlong size,
 193                     unsigned char **result)
 194 {
 195   if (size < 0)
 196     return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 197   NULL_CHECK (result);
 198   if (size == 0)
 199     *result = NULL;
 200   else
 201     {
 202       *result = (unsigned char *) _Jv_MallocUnchecked (size);
 203       if (*result == NULL)
 204         return JVMTI_ERROR_OUT_OF_MEMORY;
 205     }
 206   return JVMTI_ERROR_NONE;
 207 }
 208
 209 static jvmtiError JNICALL
 210 _Jv_JVMTI_Deallocate (MAYBE_UNUSED jvmtiEnv *env, unsigned char *mem)
 211 {
 212   if (mem != NULL)
 213     _Jv_Free (mem);
 214   return JVMTI_ERROR_NONE;
 215 }
 216
 217 static jvmtiError JNICALL
 218 _Jv_JVMTI_GetClassModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 219                              jint *mods)
 220 {
 221   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 222   // Don't bother checking KLASS' type.
 223   if (klass == NULL)
 224     return JVMTI_ERROR_INVALID_CLASS;
 225   NULL_CHECK (mods);
 226   *mods = klass->getModifiers();
 227   return JVMTI_ERROR_NONE;
 228 }
 229
 230 static jvmtiError JNICALL
 231 _Jv_JVMTI_GetClassMethods (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 232                            jint *count_ptr, jmethodID **methods_ptr)
 233 {
 234   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 235   // FIXME: capability can_maintain_original_method_order
 236   // Don't bother checking KLASS' type.
 237   if (klass == NULL)
 238     return JVMTI_ERROR_INVALID_CLASS;
 239   NULL_CHECK (count_ptr);
 240   NULL_CHECK (methods_ptr);
 241   *count_ptr = JvNumMethods(klass);
 242
 243   *methods_ptr = (jmethodID *) _Jv_Malloc (*count_ptr * sizeof (jmethodID));
 244   jmethodID start = JvGetFirstMethod (klass);
 245   for (jint i = 0; i < *count_ptr; ++i)
 246     // FIXME: correct?
 247     (*methods_ptr)[i] = start + i;
 248
 249   return JVMTI_ERROR_NONE;
 250 }
 251
 252 static jvmtiError JNICALL
 253 _Jv_JVMTI_IsInterface (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 254                        jboolean *result)
 255 {
 256   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 257   if (klass == NULL)
 258     return JVMTI_ERROR_INVALID_CLASS;
 259   NULL_CHECK (result);
 260   *result = klass->isInterface();
 261   return JVMTI_ERROR_NONE;
 262 }
 263
 264 static jvmtiError JNICALL
 265 _Jv_JVMTI_IsArrayClass (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 266                         jboolean *result)
 267 {
 268   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 269   if (klass == NULL)
 270     return JVMTI_ERROR_INVALID_CLASS;
 271   NULL_CHECK (result);
 272   *result = klass->isArray();
 273   return JVMTI_ERROR_NONE;
 274 }
 275
 276 static jvmtiError JNICALL
 277 _Jv_JVMTI_GetClassLoader (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 278                           jobject *result)
 279 {
 280   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 281   if (klass == NULL)
 282     return JVMTI_ERROR_INVALID_CLASS;
 283   NULL_CHECK (result);
 284   *result = klass->getClassLoaderInternal();
 285   return JVMTI_ERROR_NONE;
 286 }
 287
 288 static jvmtiError JNICALL
 289 _Jv_JVMTI_GetObjectHashCode (MAYBE_UNUSED jvmtiEnv *env, jobject obj,
 290                              jint *result)
 291 {
 292   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 293   if (obj == NULL)
 294     return JVMTI_ERROR_INVALID_OBJECT;
 295   NULL_CHECK (result);
 296   *result = _Jv_HashCode (obj);
 297   return JVMTI_ERROR_NONE;
 298 }
 299
 300 static jvmtiError JNICALL
 301 _Jv_JVMTI_GetFieldModifiers (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 302                              jfieldID field, jint *result)
 303 {
 304   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 305   if (klass == NULL)
 306     return JVMTI_ERROR_INVALID_CLASS;
 307   if (field == NULL)
 308     return JVMTI_ERROR_INVALID_FIELDID;
 309   NULL_CHECK (result);
 310   *result = field->getModifiers();
 311   return JVMTI_ERROR_NONE;
 312 }
 313
 314 static jvmtiError JNICALL
 315 _Jv_JVMTI_IsFieldSynthetic (MAYBE_UNUSED jvmtiEnv *env, jclass klass,
 316                             jfieldID field, jboolean *result)
 317 {
 318   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 319   if (klass == NULL)
 320     return JVMTI_ERROR_INVALID_CLASS;
 321   if (field == NULL)
 322     return JVMTI_ERROR_INVALID_FIELDID;
 323   NULL_CHECK (result);
 324
 325   // FIXME: capability can_get_synthetic_attribute
 326   *result = ((field->getModifiers() & java::lang::reflect::Modifier::SYNTHETIC)
 327              != 0);
 328   return JVMTI_ERROR_NONE;
 329 }
 330
 331 static jvmtiError JNICALL
 332 _Jv_JVMTI_GetMethodModifiers (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
 333                               jint *result)
 334 {
 335   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 336   if (method == NULL)
 337     return JVMTI_ERROR_INVALID_METHODID;
 338   NULL_CHECK (result);
 339
 340   // FIXME: mask off some internal bits...
 341   *result = method->accflags;
 342   return JVMTI_ERROR_NONE;
 343 }
 344
 345 static jvmtiError JNICALL
 346 _Jv_JVMTI_IsMethodNative (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
 347                           jboolean *result)
 348 {
 349   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 350   if (method == NULL)
 351     return JVMTI_ERROR_INVALID_METHODID;
 352   NULL_CHECK (result);
 353
 354   *result = ((method->accflags & java::lang::reflect::Modifier::NATIVE) != 0);
 355   return JVMTI_ERROR_NONE;
 356 }
 357
 358 static jvmtiError JNICALL
 359 _Jv_JVMTI_IsMethodSynthetic (MAYBE_UNUSED jvmtiEnv *env, jmethodID method,
 360                              jboolean *result)
 361 {
 362   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 363   if (method == NULL)
 364     return JVMTI_ERROR_INVALID_METHODID;
 365   NULL_CHECK (result);
 366
 367   // FIXME capability can_get_synthetic_attribute
 368
 369   *result = ((method->accflags & java::lang::reflect::Modifier::SYNTHETIC)
 370              != 0);
 371   return JVMTI_ERROR_NONE;
 372 }
 373
 374 static jvmtiError JNICALL
 375 _Jv_JVMTI_GetClassLoaderClasses (MAYBE_UNUSED jvmtiEnv *env,
 376                                  jobject init_loader,
 377                                  jint *count_ptr,
 378                                  jclass **result_ptr)
 379 {
 380   using namespace java::lang;
 381   using namespace java::util;
 382
 383   REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
 384   NULL_CHECK (count_ptr);
 385   NULL_CHECK (result_ptr);
 386
 387   ClassLoader *loader = (ClassLoader *) init_loader;
 388   if (loader == NULL)
 389     loader = VMClassLoader::bootLoader;
 390
 391   Collection *values = loader->loadedClasses->values();
 392   jobjectArray array = values->toArray();
 393   *count_ptr = array->length;
 394   jobject *elts = elements (array);
 395   jclass *result = (jclass *) _Jv_Malloc (*count_ptr * sizeof (jclass));
 396   // FIXME: JNI references...
 397   memcpy (result, elts, *count_ptr * sizeof (jclass));
 398
 399   *result_ptr = result;
 400
 401   return JVMTI_ERROR_NONE;
 402 }
 403
 404 static jvmtiError JNICALL
 405 _Jv_JVMTI_ForceGarbageCollection (MAYBE_UNUSED jvmtiEnv *env)
 406 {
 407   REQUIRE_PHASE (env, JVMTI_PHASE_LIVE);
 408   _Jv_RunGC();
 409   return JVMTI_ERROR_NONE;
 410 }
 411
 412 static jvmtiError JNICALL
 413 _Jv_JVMTI_SetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
 414                                const jniNativeInterface *function_table)
 415 {
 416   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 417   NULL_CHECK (function_table);
 418   memcpy (&_Jv_JNIFunctions, function_table, sizeof (jniNativeInterface));
 419   return JVMTI_ERROR_NONE;
 420 }
 421
 422 static jvmtiError JNICALL
 423 _Jv_JVMTI_GetJNIFunctionTable (MAYBE_UNUSED jvmtiEnv *env,
 424                                jniNativeInterface **function_table)
 425 {
 426   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 427   NULL_CHECK (function_table);
 428   *function_table
 429     = (jniNativeInterface *) _Jv_Malloc (sizeof (jniNativeInterface));
 430   memcpy (*function_table, &_Jv_JNIFunctions, sizeof (jniNativeInterface));
 431   return JVMTI_ERROR_NONE;
 432 }
 433
 434 static jvmtiError JNICALL
 435 _Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env)
 436 {
 437   // All we need to do is free memory allocated by _Jv_GetJVMTIEnv
 438   _Jv_Free (env);
 439   return JVMTI_ERROR_NONE;
 440 }
 441
 442 static jvmtiError JNICALL
 443 _Jv_JVMTI_GetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
 444                              char **result)
 445 {
 446   REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD | JVMTI_PHASE_LIVE);
 447   NULL_CHECK (property);
 448   NULL_CHECK (result);
 449
 450   jstring name = JvNewStringUTF(property);
 451   jstring result_str = gnu::classpath::SystemProperties::getProperty(name);
 452
 453   if (result_str == NULL)
 454     return JVMTI_ERROR_NOT_AVAILABLE;
 455
 456   int len = JvGetStringUTFLength (result_str);
 457   *result = (char *) _Jv_Malloc (len + 1);
 458   JvGetStringUTFRegion (result_str, 0, result_str->length(), *result);
 459   (*result)[len] = '\0';
 460
 461   return JVMTI_ERROR_NONE;
 462 }
 463
 464 static jvmtiError JNICALL
 465 _Jv_JVMTI_SetSystemProperty (MAYBE_UNUSED jvmtiEnv *env, const char *property,
 466                              const char *value)
 467 {
 468   REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
 469
 470   NULL_CHECK (property);
 471   if (value == NULL)
 472     {
 473       // FIXME: When would a property not be writeable?
 474       return JVMTI_ERROR_NONE;
 475     }
 476
 477   jstring prop_str = JvNewStringUTF(property);
 478   jstring value_str = JvNewStringUTF(value);
 479   gnu::classpath::SystemProperties::setProperty(prop_str, value_str);
 480   return JVMTI_ERROR_NONE;
 481 }
 482
 483 static jvmtiError JNICALL
 484 _Jv_JVMTI_GetTime (MAYBE_UNUSED jvmtiEnv *env, jlong *nanos_ptr)
 485 {
 486   NULL_CHECK (nanos_ptr);
 487   *nanos_ptr = _Jv_platform_nanotime();
 488   return JVMTI_ERROR_NONE;
 489 }
 490
 491 static jvmtiError JNICALL
 492 _Jv_JVMTI_GetAvailableProcessors (MAYBE_UNUSED jvmtiEnv *env,
 493                                   jint *nprocessors_ptr)
 494 {
 495   NULL_CHECK (nprocessors_ptr);
 496 #ifdef _SC_NPROCESSORS_ONLN
 497   *nprocessors_ptr = sysconf(_SC_NPROCESSORS_ONLN);
 498 #else
 499   *nprocessors_ptr = 1;
 500 #endif
 501   return JVMTI_ERROR_NONE;
 502 }
 503
 504 static jvmtiError JNICALL
 505 _Jv_JVMTI_AddToBootstrapClassLoaderSearch (MAYBE_UNUSED jvmtiEnv *env,
 506                                            const char *segment)
 507 {
 508   using namespace java::lang;
 509   using namespace java::net;
 510   using namespace gnu::gcj::runtime;
 511
 512   REQUIRE_PHASE (env, JVMTI_PHASE_ONLOAD);
 513   NULL_CHECK (segment);
 514
 515   jstring str_segment = JvNewStringUTF(segment);
 516   URL *url;
 517   try
 518     {
 519       url = new URL(JvNewStringUTF("file"), NULL, str_segment);
 520     }
 521   catch (jthrowable ignore)
 522     {
 523       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 524     }
 525
 526   BootClassLoader *loader = VMClassLoader::bootLoader;
 527   // Don't call this too early.
 528   // assert (loader != NULL);
 529   loader->addURL(url);
 530   return JVMTI_ERROR_NONE;
 531 }
 532
 533 static jvmtiError JNICALL
 534 _Jv_JVMTI_SetVerboseFlag (MAYBE_UNUSED jvmtiEnv *env, jvmtiVerboseFlag flag,
 535                           jboolean value)
 536 {
 537   switch (flag)
 538     {
 539     case JVMTI_VERBOSE_OTHER:
 540     case JVMTI_VERBOSE_GC:
 541     case JVMTI_VERBOSE_JNI:
 542       // Ignore.
 543       break;
 544     case JVMTI_VERBOSE_CLASS:
 545       gcj::verbose_class_flag = value;
 546       break;
 547     default:
 548       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
 549     }
 550   return JVMTI_ERROR_NONE;
 551 }
 552
 553 static jvmtiError JNICALL
 554 _Jv_JVMTI_GetObjectSize (MAYBE_UNUSED jvmtiEnv *env, jobject object,
 555                          jlong *result)
 556 {
 557   REQUIRE_PHASE (env, JVMTI_PHASE_START | JVMTI_PHASE_LIVE);
 558   if (object == NULL)
 559     return JVMTI_ERROR_INVALID_OBJECT;
 560   NULL_CHECK (result);
 561
 562   jclass klass = object->getClass();
 563   if (klass->isArray())
 564     {
 565       jclass comp = klass->getComponentType();
 566       jint base
 567         = (jint) (_Jv_uintptr_t) _Jv_GetArrayElementFromElementType(NULL,
 568                                                                     klass->getComponentType());
 569       // FIXME: correct for primitive types?
 570       jint compSize = comp->size();
 571       __JArray *array = (__JArray *) object;
 572       *result = base + array->length * compSize;
 573     }
 574   else
 575     {
 576       // Note that if OBJECT is a String then it may (if
 577       // str->data==str) take more space.  Do we care?
 578       *result = klass->size();
 579     }
 580   return JVMTI_ERROR_NONE;
 581 }
 582
 583 #define RESERVED NULL
 584 #define UNIMPLEMENTED NULL
 585
 586 struct _Jv_jvmtiEnv _Jv_JVMTI_Interface =
 587 {
 588   RESERVED,                     // reserved1
 589   UNIMPLEMENTED,                // SetEventNotification
 590   RESERVED,                     // reserved3
 591   UNIMPLEMENTED,                // GetAllThreads
 592   _Jv_JVMTI_SuspendThread,      // SuspendThread
 593   _Jv_JVMTI_ResumeThread,       // ResumeThread
 594   UNIMPLEMENTED,                // StopThread
 595   _Jv_JVMTI_InterruptThread,    // InterruptThread
 596   UNIMPLEMENTED,                // GetThreadInfo
 597   UNIMPLEMENTED,                // GetOwnedMonitorInfo
 598   UNIMPLEMENTED,                // GetCurrentContendedMonitor
 599   UNIMPLEMENTED,                // RunAgentThread
 600   UNIMPLEMENTED,                // GetTopThreadGroups
 601   UNIMPLEMENTED,                // GetThreadGroupInfo
 602   UNIMPLEMENTED,                // GetThreadGroupChildren
 603   UNIMPLEMENTED,                // GetFrameCount
 604   UNIMPLEMENTED,                // GetThreadState
 605   RESERVED,                     // reserved18
 606   UNIMPLEMENTED,                // GetFrameLocation
 607   UNIMPLEMENTED,                // NotifyPopFrame
 608   UNIMPLEMENTED,                // GetLocalObject
 609   UNIMPLEMENTED,                // GetLocalInt
 610   UNIMPLEMENTED,                // GetLocalLong
 611   UNIMPLEMENTED,                // GetLocalFloat
 612   UNIMPLEMENTED,                // GetLocalDouble
 613   UNIMPLEMENTED,                // SetLocalObject
 614   UNIMPLEMENTED,                // SetLocalInt
 615   UNIMPLEMENTED,                // SetLocalLong
 616   UNIMPLEMENTED,                // SetLocalFloat
 617   UNIMPLEMENTED,                // SetLocalDouble
 618   _Jv_JVMTI_CreateRawMonitor,   // CreateRawMonitor
 619   _Jv_JVMTI_DestroyRawMonitor,  // DestroyRawMonitor
 620   _Jv_JVMTI_RawMonitorEnter,    // RawMonitorEnter
 621   _Jv_JVMTI_RawMonitorExit,     // RawMonitorExit
 622   _Jv_JVMTI_RawMonitorWait,     // RawMonitorWait
 623   _Jv_JVMTI_RawMonitorNotify,   // RawMonitorNotify
 624   _Jv_JVMTI_RawMonitorNotifyAll, // RawMonitorNotifyAll
 625   UNIMPLEMENTED,                // SetBreakpoint
 626   UNIMPLEMENTED,                // ClearBreakpoint
 627   RESERVED,                     // reserved40
 628   UNIMPLEMENTED,                // SetFieldAccessWatch
 629   UNIMPLEMENTED,                // ClearFieldAccessWatch
 630   UNIMPLEMENTED,                // SetFieldModificationWatch
 631   UNIMPLEMENTED,                // ClearFieldModificationWatch
 632   RESERVED,                     // reserved45
 633   _Jv_JVMTI_Allocate,           // Allocate
 634   _Jv_JVMTI_Deallocate,         // Deallocate
 635   UNIMPLEMENTED,                // GetClassSignature
 636   UNIMPLEMENTED,                // GetClassStatus
 637   UNIMPLEMENTED,                // GetSourceFileName
 638   _Jv_JVMTI_GetClassModifiers,  // GetClassModifiers
 639   _Jv_JVMTI_GetClassMethods,    // GetClassMethods
 640   UNIMPLEMENTED,                // GetClassFields
 641   UNIMPLEMENTED,                // GetImplementedInterfaces
 642   _Jv_JVMTI_IsInterface,        // IsInterface
 643   _Jv_JVMTI_IsArrayClass,       // IsArrayClass
 644   _Jv_JVMTI_GetClassLoader,     // GetClassLoader
 645   _Jv_JVMTI_GetObjectHashCode,  // GetObjectHashCode
 646   UNIMPLEMENTED,                // GetObjectMonitorUsage
 647   UNIMPLEMENTED,                // GetFieldName
 648   UNIMPLEMENTED,                // GetFieldDeclaringClass
 649   _Jv_JVMTI_GetFieldModifiers,  // GetFieldModifiers
 650   _Jv_JVMTI_IsFieldSynthetic,   // IsFieldSynthetic
 651   UNIMPLEMENTED,                // GetMethodName
 652   UNIMPLEMENTED,                // GetMethodDeclaringClass
 653   _Jv_JVMTI_GetMethodModifiers, // GetMethodModifers
 654   RESERVED,                     // reserved67
 655   UNIMPLEMENTED,                // GetMaxLocals
 656   UNIMPLEMENTED,                // GetArgumentsSize
 657   UNIMPLEMENTED,                // GetLineNumberTable
 658   UNIMPLEMENTED,                // GetMethodLocation
 659   UNIMPLEMENTED,                // GetLocalVariableTable
 660   RESERVED,                     // reserved73
 661   RESERVED,                     // reserved74
 662   UNIMPLEMENTED,                // GetBytecodes
 663   _Jv_JVMTI_IsMethodNative,     // IsMethodNative
 664   _Jv_JVMTI_IsMethodSynthetic,  // IsMethodSynthetic
 665   UNIMPLEMENTED,                // GetLoadedClasses
 666   _Jv_JVMTI_GetClassLoaderClasses, // GetClassLoaderClasses
 667   UNIMPLEMENTED,                // PopFrame
 668   RESERVED,                     // reserved81
 669   RESERVED,                     // reserved82
 670   RESERVED,                     // reserved83
 671   RESERVED,                     // reserved84
 672   RESERVED,                     // reserved85
 673   RESERVED,                     // reserved86
 674   UNIMPLEMENTED,                // RedefineClasses
 675   UNIMPLEMENTED,                // GetVersionNumber
 676   UNIMPLEMENTED,                // GetCapabilities
 677   UNIMPLEMENTED,                // GetSourceDebugExtension
 678   UNIMPLEMENTED,                // IsMethodObsolete
 679   UNIMPLEMENTED,                // SuspendThreadList
 680   UNIMPLEMENTED,                // ResumeThreadList
 681   RESERVED,                     // reserved94
 682   RESERVED,                     // reserved95
 683   RESERVED,                     // reserved96
 684   RESERVED,                     // reserved97
 685   RESERVED,                     // reserved98
 686   RESERVED,                     // reserved99
 687   UNIMPLEMENTED,                // GetAllStackTraces
 688   UNIMPLEMENTED,                // GetThreadListStackTraces
 689   UNIMPLEMENTED,                // GetThreadLocalStorage
 690   UNIMPLEMENTED,                // SetThreadLocalStorage
 691   UNIMPLEMENTED,                // GetStackTrace
 692   RESERVED,                     // reserved105
 693   UNIMPLEMENTED,                // GetTag
 694   UNIMPLEMENTED,                // SetTag
 695   _Jv_JVMTI_ForceGarbageCollection, // ForceGarbageCollection
 696   UNIMPLEMENTED,                // IterateOverObjectsReachable
 697   UNIMPLEMENTED,                // IterateOverReachableObjects
 698   UNIMPLEMENTED,                // IterateOverHeap
 699   UNIMPLEMENTED,                // IterateOverInstanceOfClass
 700   RESERVED,                     // reserved113
 701   UNIMPLEMENTED,                // GetObjectsWithTags
 702   RESERVED,                     // reserved115
 703   RESERVED,                     // reserved116
 704   RESERVED,                     // reserved117
 705   RESERVED,                     // reserved118
 706   RESERVED,                     // reserved119
 707   _Jv_JVMTI_SetJNIFunctionTable, // SetJNIFunctionTable
 708   _Jv_JVMTI_GetJNIFunctionTable, // GetJNIFunctionTable
 709   UNIMPLEMENTED,                // SetEventCallbacks
 710   UNIMPLEMENTED,                // GenerateEvents
 711   UNIMPLEMENTED,                // GetExtensionFunctions
 712   UNIMPLEMENTED,                // GetExtensionEvents
 713   UNIMPLEMENTED,                // SetExtensionEventCallback
 714   _Jv_JVMTI_DisposeEnvironment, // DisposeEnvironment
 715   UNIMPLEMENTED,                // GetErrorName
 716   UNIMPLEMENTED,                // GetJLocationFormat
 717   UNIMPLEMENTED,                // GetSystemProperties
 718   _Jv_JVMTI_GetSystemProperty,  // GetSystemProperty
 719   _Jv_JVMTI_SetSystemProperty,  // SetSystemProperty
 720   UNIMPLEMENTED,                // GetPhase
 721   UNIMPLEMENTED,                // GetCurrentThreadCpuTimerInfo
 722   UNIMPLEMENTED,                // GetCurrentThreadCpuTime
 723   UNIMPLEMENTED,                // GetThreadCpuTimerInfo
 724   UNIMPLEMENTED,                // GetThreadCpuTime
 725   UNIMPLEMENTED,                // GetTimerInfo
 726   _Jv_JVMTI_GetTime,            // GetTime
 727   UNIMPLEMENTED,                // GetPotentialCapabilities
 728   RESERVED,                     // reserved141
 729   UNIMPLEMENTED,                // AddCapabilities
 730   UNIMPLEMENTED,                // RelinquishCapabilities
 731   _Jv_JVMTI_GetAvailableProcessors, // GetAvailableProcessors
 732   RESERVED,                     // reserved145
 733   RESERVED,                     // reserved146
 734   UNIMPLEMENTED,                // GetEnvironmentLocalStorage
 735   UNIMPLEMENTED,                // SetEnvironmentLocalStorage
 736   _Jv_JVMTI_AddToBootstrapClassLoaderSearch, // AddToBootstrapClassLoaderSearch
 737   _Jv_JVMTI_SetVerboseFlag,     // SetVerboseFlag
 738   RESERVED,                     // reserved151
 739   RESERVED,                     // reserved152
 740   RESERVED,                     // reserved153
 741   _Jv_JVMTI_GetObjectSize       // GetObjectSize
 742 };
 743
 744 _Jv_JVMTIEnv *
 745 _Jv_GetJVMTIEnv (void)
 746 {
 747   _Jv_JVMTIEnv *env
 748     = (_Jv_JVMTIEnv *) _Jv_MallocUnchecked (sizeof (_Jv_JVMTIEnv));
 749   env->p = &_Jv_JVMTI_Interface;
 750   return env;
 751 }