rev 58769 : [mq]: type-descriptor-name

   1 /*
   2  * Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <ctype.h>
  27 
  28 #include "util.h"
  29 #include "transport.h"
  30 #include "eventHandler.h"
  31 #include "threadControl.h"
  32 #include "outStream.h"
  33 #include "inStream.h"
  34 #include "invoker.h"
  35 
  36 /* Global data area */
  37 BackendGlobalData *gdata = NULL;
  38 
  39 /* Forward declarations */
  40 static jboolean isInterface(jclass clazz);
  41 static jboolean isArrayClass(jclass clazz);
  42 static char * getPropertyUTF8(JNIEnv *env, char *propertyName);
  43 
  44 /* Save an object reference for use later (create a NewGlobalRef) */
  45 void
  46 saveGlobalRef(JNIEnv *env, jobject obj, jobject *pobj)
  47 {
  48     jobject newobj;
  49 
  50     if ( pobj == NULL ) {
  51         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"saveGlobalRef pobj");
  52     }
  53     if ( *pobj != NULL ) {
  54         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"saveGlobalRef *pobj");
  55     }
  56     if ( env == NULL ) {
  57         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"saveGlobalRef env");
  58     }
  59     if ( obj == NULL ) {
  60         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"saveGlobalRef obj");
  61     }
  62     newobj = JNI_FUNC_PTR(env,NewGlobalRef)(env, obj);
  63     if ( newobj == NULL ) {
  64         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"NewGlobalRef");
  65     }
  66     *pobj = newobj;
  67 }
  68 
  69 /* Toss a previously saved object reference */
  70 void
  71 tossGlobalRef(JNIEnv *env, jobject *pobj)
  72 {
  73     jobject obj;
  74 
  75     if ( pobj == NULL ) {
  76         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"tossGlobalRef pobj");
  77     }
  78     obj = *pobj;
  79     if ( env == NULL ) {
  80         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"tossGlobalRef env");
  81     }
  82     if ( obj == NULL ) {
  83         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"tossGlobalRef obj");
  84     }
  85     JNI_FUNC_PTR(env,DeleteGlobalRef)(env, obj);
  86     *pobj = NULL;
  87 }
  88 
  89 jclass
  90 findClass(JNIEnv *env, const char * name)
  91 {
  92     jclass x;
  93 
  94     if ( env == NULL ) {
  95         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"findClass env");
  96     }
  97     if ( name == NULL || name[0] == 0 ) {
  98         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"findClass name");
  99     }
 100     x = JNI_FUNC_PTR(env,FindClass)(env, name);
 101     if (x == NULL) {
 102         ERROR_MESSAGE(("JDWP Can't find class %s", name));
 103         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 104     }
 105     if ( JNI_FUNC_PTR(env,ExceptionOccurred)(env) ) {
 106         ERROR_MESSAGE(("JDWP Exception occurred finding class %s", name));
 107         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 108     }
 109     return x;
 110 }
 111 
 112 jmethodID
 113 getMethod(JNIEnv *env, jclass clazz, const char * name, const char *signature)
 114 {
 115     jmethodID method;
 116 
 117     if ( env == NULL ) {
 118         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getMethod env");
 119     }
 120     if ( clazz == NULL ) {
 121         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getMethod clazz");
 122     }
 123     if ( name == NULL || name[0] == 0 ) {
 124         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getMethod name");
 125     }
 126     if ( signature == NULL || signature[0] == 0 ) {
 127         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getMethod signature");
 128     }
 129     method = JNI_FUNC_PTR(env,GetMethodID)(env, clazz, name, signature);
 130     if (method == NULL) {
 131         ERROR_MESSAGE(("JDWP Can't find method %s with signature %s",
 132                                 name, signature));
 133         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 134     }
 135     if ( JNI_FUNC_PTR(env,ExceptionOccurred)(env) ) {
 136         ERROR_MESSAGE(("JDWP Exception occurred finding method %s with signature %s",
 137                                 name, signature));
 138         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 139     }
 140     return method;
 141 }
 142 
 143 static jmethodID
 144 getStaticMethod(JNIEnv *env, jclass clazz, const char * name, const char *signature)
 145 {
 146     jmethodID method;
 147 
 148     if ( env == NULL ) {
 149         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getStaticMethod env");
 150     }
 151     if ( clazz == NULL ) {
 152         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getStaticMethod clazz");
 153     }
 154     if ( name == NULL || name[0] == 0 ) {
 155         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getStaticMethod name");
 156     }
 157     if ( signature == NULL || signature[0] == 0 ) {
 158         EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"getStaticMethod signature");
 159     }
 160     method = JNI_FUNC_PTR(env,GetStaticMethodID)(env, clazz, name, signature);
 161     if (method == NULL) {
 162         ERROR_MESSAGE(("JDWP Can't find method %s with signature %s",
 163                                 name, signature));
 164         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 165     }
 166     if ( JNI_FUNC_PTR(env,ExceptionOccurred)(env) ) {
 167         ERROR_MESSAGE(("JDWP Exception occurred finding method %s with signature %s",
 168                                 name, signature));
 169         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
 170     }
 171     return method;
 172 }
 173 
 174 void
 175 util_initialize(JNIEnv *env)
 176 {
 177     WITH_LOCAL_REFS(env, 6) {
 178 
 179         jvmtiError error;
 180         jclass localClassClass;
 181         jclass localThreadClass;
 182         jclass localThreadGroupClass;
 183         jclass localClassLoaderClass;
 184         jclass localStringClass;
 185         jclass localSystemClass;
 186         jclass localPropertiesClass;
 187         jclass localVMSupportClass;
 188         jobject localAgentProperties;
 189         jmethodID getAgentProperties;
 190         jint groupCount;
 191         jthreadGroup *groups;
 192         jthreadGroup localSystemThreadGroup;
 193 
 194         /* Find some standard classes */
 195 
 196         localClassClass         = findClass(env,"java/lang/Class");
 197         localThreadClass        = findClass(env,"java/lang/Thread");
 198         localThreadGroupClass   = findClass(env,"java/lang/ThreadGroup");
 199         localClassLoaderClass   = findClass(env,"java/lang/ClassLoader");
 200         localStringClass        = findClass(env,"java/lang/String");
 201         localSystemClass        = findClass(env,"java/lang/System");
 202         localPropertiesClass    = findClass(env,"java/util/Properties");
 203 
 204         /* Save references */
 205 
 206         saveGlobalRef(env, localClassClass,       &(gdata->classClass));
 207         saveGlobalRef(env, localThreadClass,      &(gdata->threadClass));
 208         saveGlobalRef(env, localThreadGroupClass, &(gdata->threadGroupClass));
 209         saveGlobalRef(env, localClassLoaderClass, &(gdata->classLoaderClass));
 210         saveGlobalRef(env, localStringClass,      &(gdata->stringClass));
 211         saveGlobalRef(env, localSystemClass,      &(gdata->systemClass));
 212 
 213         /* Find some standard methods */
 214 
 215         gdata->threadConstructor =
 216                 getMethod(env, gdata->threadClass,
 217                     "<init>", "(Ljava/lang/ThreadGroup;Ljava/lang/String;)V");
 218         gdata->threadSetDaemon =
 219                 getMethod(env, gdata->threadClass, "setDaemon", "(Z)V");
 220         gdata->threadResume =
 221                 getMethod(env, gdata->threadClass, "resume", "()V");
 222         gdata->systemGetProperty =
 223                 getStaticMethod(env, gdata->systemClass,
 224                     "getProperty", "(Ljava/lang/String;)Ljava/lang/String;");
 225         gdata->setProperty =
 226                 getMethod(env, localPropertiesClass,
 227                     "setProperty", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");
 228 
 229         /* Find the system thread group */
 230 
 231         groups = NULL;
 232         groupCount = 0;
 233         error = JVMTI_FUNC_PTR(gdata->jvmti,GetTopThreadGroups)
 234                     (gdata->jvmti, &groupCount, &groups);
 235         if (error != JVMTI_ERROR_NONE ) {
 236             EXIT_ERROR(error, "Can't get system thread group");
 237         }
 238         if ( groupCount == 0 ) {
 239             EXIT_ERROR(AGENT_ERROR_NULL_POINTER, "Can't get system thread group");
 240         }
 241         localSystemThreadGroup = groups[0];
 242         saveGlobalRef(env, localSystemThreadGroup, &(gdata->systemThreadGroup));
 243 
 244         /* Get some basic Java property values we will need at some point */
 245         gdata->property_java_version
 246                         = getPropertyUTF8(env, "java.version");
 247         gdata->property_java_vm_name
 248                         = getPropertyUTF8(env, "java.vm.name");
 249         gdata->property_java_vm_info
 250                         = getPropertyUTF8(env, "java.vm.info");
 251         gdata->property_java_class_path
 252                         = getPropertyUTF8(env, "java.class.path");
 253         gdata->property_sun_boot_library_path
 254                         = getPropertyUTF8(env, "sun.boot.library.path");
 255         gdata->property_path_separator
 256                         = getPropertyUTF8(env, "path.separator");
 257         gdata->property_user_dir
 258                         = getPropertyUTF8(env, "user.dir");
 259 
 260         /* Get agent properties: invoke VMSupport.getAgentProperties */
 261         localVMSupportClass = JNI_FUNC_PTR(env,FindClass)
 262                                           (env, "jdk/internal/vm/VMSupport");
 263         if (localVMSupportClass == NULL) {
 264             gdata->agent_properties = NULL;
 265             if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
 266                 JNI_FUNC_PTR(env,ExceptionClear)(env);
 267             }
 268         } else {
 269             getAgentProperties  =
 270                 getStaticMethod(env, localVMSupportClass,
 271                                 "getAgentProperties", "()Ljava/util/Properties;");
 272             localAgentProperties =
 273                 JNI_FUNC_PTR(env,CallStaticObjectMethod)
 274                             (env, localVMSupportClass, getAgentProperties);
 275             saveGlobalRef(env, localAgentProperties, &(gdata->agent_properties));
 276             if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
 277                 JNI_FUNC_PTR(env,ExceptionClear)(env);
 278                 EXIT_ERROR(AGENT_ERROR_INTERNAL,
 279                     "Exception occurred calling VMSupport.getAgentProperties");
 280             }
 281         }
 282 
 283     } END_WITH_LOCAL_REFS(env);
 284 
 285 }
 286 
 287 void
 288 util_reset(void)
 289 {
 290 }
 291 
 292 jboolean
 293 isObjectTag(jbyte tag) {
 294     return (tag == JDWP_TAG(OBJECT)) ||
 295            (tag == JDWP_TAG(STRING)) ||
 296            (tag == JDWP_TAG(THREAD)) ||
 297            (tag == JDWP_TAG(THREAD_GROUP)) ||
 298            (tag == JDWP_TAG(CLASS_LOADER)) ||
 299            (tag == JDWP_TAG(CLASS_OBJECT)) ||
 300            (tag == JDWP_TAG(ARRAY));
 301 }
 302 
 303 jbyte
 304 specificTypeKey(JNIEnv *env, jobject object)
 305 {
 306     if (object == NULL) {
 307         return JDWP_TAG(OBJECT);
 308     } else if (JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->stringClass)) {
 309         return JDWP_TAG(STRING);
 310     } else if (JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->threadClass)) {
 311         return JDWP_TAG(THREAD);
 312     } else if (JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->threadGroupClass)) {
 313         return JDWP_TAG(THREAD_GROUP);
 314     } else if (JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->classLoaderClass)) {
 315         return JDWP_TAG(CLASS_LOADER);
 316     } else if (JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->classClass)) {
 317         return JDWP_TAG(CLASS_OBJECT);
 318     } else {
 319         jboolean classIsArray;
 320 
 321         WITH_LOCAL_REFS(env, 1) {
 322             jclass clazz;
 323             clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, object);
 324             classIsArray = isArrayClass(clazz);
 325         } END_WITH_LOCAL_REFS(env);
 326 
 327         return (classIsArray ? JDWP_TAG(ARRAY) : JDWP_TAG(OBJECT));
 328     }
 329 }
 330 
 331 static void
 332 writeFieldValue(JNIEnv *env, PacketOutputStream *out, jobject object,
 333                 jfieldID field)
 334 {
 335     jclass clazz;
 336     char *signature = NULL;
 337     jvmtiError error;
 338     jbyte typeKey;
 339 
 340     clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, object);
 341     error = fieldSignature(clazz, field, NULL, &signature, NULL);
 342     if (error != JVMTI_ERROR_NONE) {
 343         outStream_setError(out, map2jdwpError(error));
 344         return;
 345     }
 346     typeKey = signature[0];
 347     jvmtiDeallocate(signature);
 348 
 349     /*
 350      * For primitive types, the type key is bounced back as is. Objects
 351      * are handled in the switch statement below.
 352      */
 353     if ((typeKey != JDWP_TAG(OBJECT)) && (typeKey != JDWP_TAG(ARRAY))) {
 354         (void)outStream_writeByte(out, typeKey);
 355     }
 356 
 357     switch (typeKey) {
 358         case JDWP_TAG(OBJECT):
 359         case JDWP_TAG(ARRAY):   {
 360             jobject value = JNI_FUNC_PTR(env,GetObjectField)(env, object, field);
 361             (void)outStream_writeByte(out, specificTypeKey(env, value));
 362             (void)outStream_writeObjectRef(env, out, value);
 363             break;
 364         }
 365 
 366         case JDWP_TAG(BYTE):
 367             (void)outStream_writeByte(out,
 368                       JNI_FUNC_PTR(env,GetByteField)(env, object, field));
 369             break;
 370 
 371         case JDWP_TAG(CHAR):
 372             (void)outStream_writeChar(out,
 373                       JNI_FUNC_PTR(env,GetCharField)(env, object, field));
 374             break;
 375 
 376         case JDWP_TAG(FLOAT):
 377             (void)outStream_writeFloat(out,
 378                       JNI_FUNC_PTR(env,GetFloatField)(env, object, field));
 379             break;
 380 
 381         case JDWP_TAG(DOUBLE):
 382             (void)outStream_writeDouble(out,
 383                       JNI_FUNC_PTR(env,GetDoubleField)(env, object, field));
 384             break;
 385 
 386         case JDWP_TAG(INT):
 387             (void)outStream_writeInt(out,
 388                       JNI_FUNC_PTR(env,GetIntField)(env, object, field));
 389             break;
 390 
 391         case JDWP_TAG(LONG):
 392             (void)outStream_writeLong(out,
 393                       JNI_FUNC_PTR(env,GetLongField)(env, object, field));
 394             break;
 395 
 396         case JDWP_TAG(SHORT):
 397             (void)outStream_writeShort(out,
 398                       JNI_FUNC_PTR(env,GetShortField)(env, object, field));
 399             break;
 400 
 401         case JDWP_TAG(BOOLEAN):
 402             (void)outStream_writeBoolean(out,
 403                       JNI_FUNC_PTR(env,GetBooleanField)(env, object, field));
 404             break;
 405     }
 406 }
 407 
 408 static void
 409 writeStaticFieldValue(JNIEnv *env, PacketOutputStream *out, jclass clazz,
 410                       jfieldID field)
 411 {
 412     jvmtiError error;
 413     char *signature = NULL;
 414     jbyte typeKey;
 415 
 416     error = fieldSignature(clazz, field, NULL, &signature, NULL);
 417     if (error != JVMTI_ERROR_NONE) {
 418         outStream_setError(out, map2jdwpError(error));
 419         return;
 420     }
 421     typeKey = signature[0];
 422     jvmtiDeallocate(signature);
 423 
 424     /*
 425      * For primitive types, the type key is bounced back as is. Objects
 426      * are handled in the switch statement below.
 427      */
 428     if ((typeKey != JDWP_TAG(OBJECT)) && (typeKey != JDWP_TAG(ARRAY))) {
 429         (void)outStream_writeByte(out, typeKey);
 430     }
 431 
 432     switch (typeKey) {
 433         case JDWP_TAG(OBJECT):
 434         case JDWP_TAG(ARRAY):   {
 435             jobject value = JNI_FUNC_PTR(env,GetStaticObjectField)(env, clazz, field);
 436             (void)outStream_writeByte(out, specificTypeKey(env, value));
 437             (void)outStream_writeObjectRef(env, out, value);
 438             break;
 439         }
 440 
 441         case JDWP_TAG(BYTE):
 442             (void)outStream_writeByte(out,
 443                       JNI_FUNC_PTR(env,GetStaticByteField)(env, clazz, field));
 444             break;
 445 
 446         case JDWP_TAG(CHAR):
 447             (void)outStream_writeChar(out,
 448                       JNI_FUNC_PTR(env,GetStaticCharField)(env, clazz, field));
 449             break;
 450 
 451         case JDWP_TAG(FLOAT):
 452             (void)outStream_writeFloat(out,
 453                       JNI_FUNC_PTR(env,GetStaticFloatField)(env, clazz, field));
 454             break;
 455 
 456         case JDWP_TAG(DOUBLE):
 457             (void)outStream_writeDouble(out,
 458                       JNI_FUNC_PTR(env,GetStaticDoubleField)(env, clazz, field));
 459             break;
 460 
 461         case JDWP_TAG(INT):
 462             (void)outStream_writeInt(out,
 463                       JNI_FUNC_PTR(env,GetStaticIntField)(env, clazz, field));
 464             break;
 465 
 466         case JDWP_TAG(LONG):
 467             (void)outStream_writeLong(out,
 468                       JNI_FUNC_PTR(env,GetStaticLongField)(env, clazz, field));
 469             break;
 470 
 471         case JDWP_TAG(SHORT):
 472             (void)outStream_writeShort(out,
 473                       JNI_FUNC_PTR(env,GetStaticShortField)(env, clazz, field));
 474             break;
 475 
 476         case JDWP_TAG(BOOLEAN):
 477             (void)outStream_writeBoolean(out,
 478                       JNI_FUNC_PTR(env,GetStaticBooleanField)(env, clazz, field));
 479             break;
 480     }
 481 }
 482 
 483 void
 484 sharedGetFieldValues(PacketInputStream *in, PacketOutputStream *out,
 485                      jboolean isStatic)
 486 {
 487     JNIEnv *env = getEnv();
 488     jint length;
 489     jobject object;
 490     jclass clazz;
 491 
 492     object = NULL;
 493     clazz  = NULL;
 494 
 495     if (isStatic) {
 496         clazz = inStream_readClassRef(env, in);
 497     } else {
 498         object = inStream_readObjectRef(env, in);
 499     }
 500 
 501     length = inStream_readInt(in);
 502     if (inStream_error(in)) {
 503         return;
 504     }
 505 
 506     WITH_LOCAL_REFS(env, length + 1) { /* +1 for class with instance fields */
 507 
 508         int i;
 509 
 510         (void)outStream_writeInt(out, length);
 511         for (i = 0; (i < length) && !outStream_error(out); i++) {
 512             jfieldID field = inStream_readFieldID(in);
 513 
 514             if (isStatic) {
 515                 writeStaticFieldValue(env, out, clazz, field);
 516             } else {
 517                 writeFieldValue(env, out, object, field);
 518             }
 519         }
 520 
 521     } END_WITH_LOCAL_REFS(env);
 522 }
 523 
 524 jboolean
 525 sharedInvoke(PacketInputStream *in, PacketOutputStream *out)
 526 {
 527     jvalue *arguments = NULL;
 528     jint options;
 529     jvmtiError error;
 530     jbyte invokeType;
 531     jclass clazz;
 532     jmethodID method;
 533     jint argumentCount;
 534     jobject instance;
 535     jthread thread;
 536     JNIEnv *env;
 537 
 538     /*
 539      * Instance methods start with the instance, thread and class,
 540      * and statics and constructors start with the class and then the
 541      * thread.
 542      */
 543     env = getEnv();
 544     if (inStream_command(in) == JDWP_COMMAND(ObjectReference, InvokeMethod)) {
 545         instance = inStream_readObjectRef(env, in);
 546         thread = inStream_readThreadRef(env, in);
 547         clazz = inStream_readClassRef(env, in);
 548     } else { /* static method or constructor */
 549         instance = NULL;
 550         clazz = inStream_readClassRef(env, in);
 551         thread = inStream_readThreadRef(env, in);
 552     }
 553 
 554     /*
 555      * ... and the rest of the packet is identical for all commands
 556      */
 557     method = inStream_readMethodID(in);
 558     argumentCount = inStream_readInt(in);
 559     if (inStream_error(in)) {
 560         return JNI_TRUE;
 561     }
 562 
 563     /* If count == 0, don't try and allocate 0 bytes, you'll get NULL */
 564     if ( argumentCount > 0 ) {
 565         int i;
 566         /*LINTED*/
 567         arguments = jvmtiAllocate(argumentCount * (jint)sizeof(*arguments));
 568         if (arguments == NULL) {
 569             outStream_setError(out, JDWP_ERROR(OUT_OF_MEMORY));
 570             return JNI_TRUE;
 571         }
 572         for (i = 0; (i < argumentCount) && !inStream_error(in); i++) {
 573             arguments[i] = inStream_readValue(in, NULL);
 574         }
 575         if (inStream_error(in)) {
 576             return JNI_TRUE;
 577         }
 578     }
 579 
 580     options = inStream_readInt(in);
 581     if (inStream_error(in)) {
 582         if ( arguments != NULL ) {
 583             jvmtiDeallocate(arguments);
 584         }
 585         return JNI_TRUE;
 586     }
 587 
 588     if (inStream_command(in) == JDWP_COMMAND(ClassType, NewInstance)) {
 589         invokeType = INVOKE_CONSTRUCTOR;
 590     } else if (inStream_command(in) == JDWP_COMMAND(ClassType, InvokeMethod)) {
 591         invokeType = INVOKE_STATIC;
 592     } else if (inStream_command(in) == JDWP_COMMAND(InterfaceType, InvokeMethod)) {
 593         invokeType = INVOKE_STATIC;
 594     } else if (inStream_command(in) == JDWP_COMMAND(ObjectReference, InvokeMethod)) {
 595         invokeType = INVOKE_INSTANCE;
 596     } else {
 597         outStream_setError(out, JDWP_ERROR(INTERNAL));
 598         if ( arguments != NULL ) {
 599             jvmtiDeallocate(arguments);
 600         }
 601         return JNI_TRUE;
 602     }
 603 
 604     /*
 605      * Request the invoke. If there are no errors in the request,
 606      * the interrupting thread will actually do the invoke and a
 607      * reply will be generated subsequently, so we don't reply here.
 608      */
 609     error = invoker_requestInvoke(invokeType, (jbyte)options, inStream_id(in),
 610                                   thread, clazz, method,
 611                                   instance, arguments, argumentCount);
 612     if (error != JVMTI_ERROR_NONE) {
 613         outStream_setError(out, map2jdwpError(error));
 614         if ( arguments != NULL ) {
 615             jvmtiDeallocate(arguments);
 616         }
 617         return JNI_TRUE;
 618     }
 619 
 620     return JNI_FALSE;   /* Don't reply */
 621 }
 622 
 623 jint
 624 uniqueID(void)
 625 {
 626     static jint currentID = 0;
 627     return currentID++;
 628 }
 629 
 630 int
 631 filterDebugThreads(jthread *threads, int count)
 632 {
 633     int i;
 634     int current;
 635 
 636     /* Squish out all of the debugger-spawned threads */
 637     for (i = 0, current = 0; i < count; i++) {
 638         jthread thread = threads[i];
 639         if (!threadControl_isDebugThread(thread)) {
 640             if (i > current) {
 641                 threads[current] = thread;
 642             }
 643             current++;
 644         }
 645     }
 646     return current;
 647 }
 648 
 649 jbyte
 650 referenceTypeTag(jclass clazz)
 651 {
 652     jbyte tag;
 653 
 654     if (isInterface(clazz)) {
 655         tag = JDWP_TYPE_TAG(INTERFACE);
 656     } else if (isArrayClass(clazz)) {
 657         tag = JDWP_TYPE_TAG(ARRAY);
 658     } else {
 659         tag = JDWP_TYPE_TAG(CLASS);
 660     }
 661 
 662     return tag;
 663 }
 664 
 665 /**
 666  * Get field modifiers
 667  */
 668 jvmtiError
 669 fieldModifiers(jclass clazz, jfieldID field, jint *pmodifiers)
 670 {
 671     jvmtiError error;
 672 
 673     *pmodifiers = 0;
 674     error = JVMTI_FUNC_PTR(gdata->jvmti,GetFieldModifiers)
 675             (gdata->jvmti, clazz, field, pmodifiers);
 676     return error;
 677 }
 678 
 679 /**
 680  * Get method modifiers
 681  */
 682 jvmtiError
 683 methodModifiers(jmethodID method, jint *pmodifiers)
 684 {
 685     jvmtiError error;
 686 
 687     *pmodifiers = 0;
 688     error = JVMTI_FUNC_PTR(gdata->jvmti,GetMethodModifiers)
 689             (gdata->jvmti, method, pmodifiers);
 690     return error;
 691 }
 692 
 693 /* Returns a local ref to the declaring class for a method, or NULL. */
 694 jvmtiError
 695 methodClass(jmethodID method, jclass *pclazz)
 696 {
 697     jvmtiError error;
 698 
 699     *pclazz = NULL;
 700     error = FUNC_PTR(gdata->jvmti,GetMethodDeclaringClass)
 701                                 (gdata->jvmti, method, pclazz);
 702     return error;
 703 }
 704 
 705 /* Returns a local ref to the declaring class for a method, or NULL. */
 706 jvmtiError
 707 methodLocation(jmethodID method, jlocation *ploc1, jlocation *ploc2)
 708 {
 709     jvmtiError error;
 710 
 711     error = JVMTI_FUNC_PTR(gdata->jvmti,GetMethodLocation)
 712                                 (gdata->jvmti, method, ploc1, ploc2);
 713     return error;
 714 }
 715 
 716 /**
 717  * Get method signature
 718  */
 719 jvmtiError
 720 methodSignature(jmethodID method,
 721         char **pname, char **psignature, char **pgeneric_signature)
 722 {
 723     jvmtiError error;
 724     char *name = NULL;
 725     char *signature = NULL;
 726     char *generic_signature = NULL;
 727 
 728     error = FUNC_PTR(gdata->jvmti,GetMethodName)
 729             (gdata->jvmti, method, &name, &signature, &generic_signature);
 730 
 731     if ( pname != NULL ) {
 732         *pname = name;
 733     } else if ( name != NULL )  {
 734         jvmtiDeallocate(name);
 735     }
 736     if ( psignature != NULL ) {
 737         *psignature = signature;
 738     } else if ( signature != NULL ) {
 739         jvmtiDeallocate(signature);
 740     }
 741     if ( pgeneric_signature != NULL ) {
 742         *pgeneric_signature = generic_signature;
 743     } else if ( generic_signature != NULL )  {
 744         jvmtiDeallocate(generic_signature);
 745     }
 746     return error;
 747 }
 748 
 749 /*
 750  * Get the return type key of the method
 751  *     V or B C D F I J S Z L  [
 752  */
 753 jvmtiError
 754 methodReturnType(jmethodID method, char *typeKey)
 755 {
 756     char       *signature;
 757     jvmtiError  error;
 758 
 759     signature = NULL;
 760     error     = methodSignature(method, NULL, &signature, NULL);
 761     if (error == JVMTI_ERROR_NONE) {
 762         if (signature == NULL ) {
 763             error = AGENT_ERROR_INVALID_TAG;
 764         } else {
 765             char * xx;
 766 
 767             xx = strchr(signature, ')');
 768             if (xx == NULL || *(xx + 1) == 0) {
 769                 error = AGENT_ERROR_INVALID_TAG;
 770             } else {
 771                *typeKey = *(xx + 1);
 772             }
 773             jvmtiDeallocate(signature);
 774         }
 775     }
 776     return error;
 777 }
 778 
 779 
 780 /**
 781  * Return class loader for a class (must be inside a WITH_LOCAL_REFS)
 782  */
 783 jvmtiError
 784 classLoader(jclass clazz, jobject *pclazz)
 785 {
 786     jvmtiError error;
 787 
 788     *pclazz = NULL;
 789     error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassLoader)
 790             (gdata->jvmti, clazz, pclazz);
 791     return error;
 792 }
 793 
 794 /**
 795  * Get field signature
 796  */
 797 jvmtiError
 798 fieldSignature(jclass clazz, jfieldID field,
 799         char **pname, char **psignature, char **pgeneric_signature)
 800 {
 801     jvmtiError error;
 802     char *name = NULL;
 803     char *signature = NULL;
 804     char *generic_signature = NULL;
 805 
 806     error = JVMTI_FUNC_PTR(gdata->jvmti,GetFieldName)
 807             (gdata->jvmti, clazz, field, &name, &signature, &generic_signature);
 808 
 809     if ( pname != NULL ) {
 810         *pname = name;
 811     } else if ( name != NULL )  {
 812         jvmtiDeallocate(name);
 813     }
 814     if ( psignature != NULL ) {
 815         *psignature = signature;
 816     } else if ( signature != NULL )  {
 817         jvmtiDeallocate(signature);
 818     }
 819     if ( pgeneric_signature != NULL ) {
 820         *pgeneric_signature = generic_signature;
 821     } else if ( generic_signature != NULL )  {
 822         jvmtiDeallocate(generic_signature);
 823     }
 824     return error;
 825 }
 826 
 827 JNIEnv *
 828 getEnv(void)
 829 {
 830     JNIEnv *env = NULL;
 831     jint rc;
 832 
 833     rc = FUNC_PTR(gdata->jvm,GetEnv)
 834                 (gdata->jvm, (void **)&env, JNI_VERSION_1_2);
 835     if (rc != JNI_OK) {
 836         ERROR_MESSAGE(("JDWP Unable to get JNI 1.2 environment, jvm->GetEnv() return code = %d",
 837                 rc));
 838         EXIT_ERROR(AGENT_ERROR_NO_JNI_ENV,NULL);
 839     }
 840     return env;
 841 }
 842 
 843 jvmtiError
 844 spawnNewThread(jvmtiStartFunction func, void *arg, char *name)
 845 {
 846     JNIEnv *env = getEnv();
 847     jvmtiError error;
 848 
 849     LOG_MISC(("Spawning new thread: %s", name));
 850 
 851     WITH_LOCAL_REFS(env, 3) {
 852 
 853         jthread thread;
 854         jstring nameString;
 855 
 856         nameString = JNI_FUNC_PTR(env,NewStringUTF)(env, name);
 857         if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
 858             JNI_FUNC_PTR(env,ExceptionClear)(env);
 859             error = AGENT_ERROR_OUT_OF_MEMORY;
 860             goto err;
 861         }
 862 
 863         thread = JNI_FUNC_PTR(env,NewObject)
 864                         (env, gdata->threadClass, gdata->threadConstructor,
 865                                    gdata->systemThreadGroup, nameString);
 866         if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
 867             JNI_FUNC_PTR(env,ExceptionClear)(env);
 868             error = AGENT_ERROR_OUT_OF_MEMORY;
 869             goto err;
 870         }
 871 
 872         /*
 873          * Make the debugger thread a daemon
 874          */
 875         JNI_FUNC_PTR(env,CallVoidMethod)
 876                         (env, thread, gdata->threadSetDaemon, JNI_TRUE);
 877         if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
 878             JNI_FUNC_PTR(env,ExceptionClear)(env);
 879             error = AGENT_ERROR_JNI_EXCEPTION;
 880             goto err;
 881         }
 882 
 883         error = threadControl_addDebugThread(thread);
 884         if (error == JVMTI_ERROR_NONE) {
 885             /*
 886              * Debugger threads need cycles in all sorts of strange
 887              * situations (e.g. infinite cpu-bound loops), so give the
 888              * thread a high priority. Note that if the VM has an application
 889              * thread running at the max priority, there is still a chance
 890              * that debugger threads will be starved. (There needs to be
 891              * a way to give debugger threads a priority higher than any
 892              * application thread).
 893              */
 894             error = JVMTI_FUNC_PTR(gdata->jvmti,RunAgentThread)
 895                         (gdata->jvmti, thread, func, arg,
 896                                         JVMTI_THREAD_MAX_PRIORITY);
 897         }
 898 
 899         err: ;
 900 
 901     } END_WITH_LOCAL_REFS(env);
 902 
 903     return error;
 904 }
 905 
 906 jvmtiError
 907 jvmtiGetCapabilities(jvmtiCapabilities *caps)
 908 {
 909     if ( gdata->vmDead ) {
 910         return AGENT_ERROR_VM_DEAD;
 911     }
 912     if (!gdata->haveCachedJvmtiCapabilities) {
 913         jvmtiError error;
 914 
 915         error = JVMTI_FUNC_PTR(gdata->jvmti,GetCapabilities)
 916                         (gdata->jvmti, &(gdata->cachedJvmtiCapabilities));
 917         if (error != JVMTI_ERROR_NONE) {
 918             return error;
 919         }
 920         gdata->haveCachedJvmtiCapabilities = JNI_TRUE;
 921     }
 922 
 923     *caps = gdata->cachedJvmtiCapabilities;
 924 
 925     return JVMTI_ERROR_NONE;
 926 }
 927 
 928 static jint
 929 jvmtiVersion(void)
 930 {
 931     if (gdata->cachedJvmtiVersion == 0) {
 932         jvmtiError error;
 933         error = JVMTI_FUNC_PTR(gdata->jvmti,GetVersionNumber)
 934                         (gdata->jvmti, &(gdata->cachedJvmtiVersion));
 935         if (error != JVMTI_ERROR_NONE) {
 936             EXIT_ERROR(error, "on getting the JVMTI version number");
 937         }
 938     }
 939     return gdata->cachedJvmtiVersion;
 940 }
 941 
 942 jint
 943 jvmtiMajorVersion(void)
 944 {
 945     return (jvmtiVersion() & JVMTI_VERSION_MASK_MAJOR)
 946                     >> JVMTI_VERSION_SHIFT_MAJOR;
 947 }
 948 
 949 jint
 950 jvmtiMinorVersion(void)
 951 {
 952     return (jvmtiVersion() & JVMTI_VERSION_MASK_MINOR)
 953                     >> JVMTI_VERSION_SHIFT_MINOR;
 954 }
 955 
 956 jint
 957 jvmtiMicroVersion(void)
 958 {
 959     return (jvmtiVersion() & JVMTI_VERSION_MASK_MICRO)
 960                     >> JVMTI_VERSION_SHIFT_MICRO;
 961 }
 962 
 963 jboolean
 964 canSuspendResumeThreadLists(void)
 965 {
 966     jvmtiError error;
 967     jvmtiCapabilities cap;
 968 
 969     error = jvmtiGetCapabilities(&cap);
 970     return (error == JVMTI_ERROR_NONE && cap.can_suspend);
 971 }
 972 
 973 jvmtiError
 974 getSourceDebugExtension(jclass clazz, char **extensionPtr)
 975 {
 976     return JVMTI_FUNC_PTR(gdata->jvmti,GetSourceDebugExtension)
 977                 (gdata->jvmti, clazz, extensionPtr);
 978 }
 979 
 980 /*
 981  * Convert the signature "Ljava/lang/Foo;" to a
 982  * classname "java.lang.Foo" compatible with the pattern.
 983  * Signature is overwritten in-place.
 984  */
 985 void
 986 convertSignatureToClassname(char *convert)
 987 {
 988     char *p;
 989 
 990     p = convert + 1;
 991     while ((*p != ';') && (*p != '\0')) {
 992         char c = *p;
 993         if (c == '/') {
 994             *(p-1) = '.';




 995         } else {
 996             *(p-1) = c;
 997         }
 998         p++;
 999     }
1000     *(p-1) = '\0';
1001 }
1002 
1003 static void
1004 handleInterrupt(void)
1005 {
1006     /*
1007      * An interrupt is handled:
1008      *
1009      * 1) for running application threads by deferring the interrupt
1010      * until the current event handler has concluded.
1011      *
1012      * 2) for debugger threads by ignoring the interrupt; this is the
1013      * most robust solution since debugger threads don't use interrupts
1014      * to signal any condition.
1015      *
1016      * 3) for application threads that have not started or already
1017      * ended by ignoring the interrupt. In the former case, the application
1018      * is relying on timing to determine whether or not the thread sees
1019      * the interrupt; in the latter case, the interrupt is meaningless.
1020      */
1021     jthread thread = threadControl_currentThread();
1022     if ((thread != NULL) && (!threadControl_isDebugThread(thread))) {
1023         threadControl_setPendingInterrupt(thread);
1024     }
1025 }
1026 
1027 static jvmtiError
1028 ignore_vm_death(jvmtiError error)
1029 {
1030     if (error == JVMTI_ERROR_WRONG_PHASE) {
1031         LOG_MISC(("VM_DEAD, in debugMonitor*()?"));
1032         return JVMTI_ERROR_NONE; /* JVMTI does this, not JVMDI? */
1033     }
1034     return error;
1035 }
1036 
1037 void
1038 debugMonitorEnter(jrawMonitorID monitor)
1039 {
1040     jvmtiError error;
1041     while (JNI_TRUE) {
1042         error = FUNC_PTR(gdata->jvmti,RawMonitorEnter)
1043                         (gdata->jvmti, monitor);
1044         error = ignore_vm_death(error);
1045         if (error == JVMTI_ERROR_INTERRUPT) {
1046             handleInterrupt();
1047         } else {
1048             break;
1049         }
1050     }
1051     if (error != JVMTI_ERROR_NONE) {
1052         EXIT_ERROR(error, "on raw monitor enter");
1053     }
1054 }
1055 
1056 void
1057 debugMonitorExit(jrawMonitorID monitor)
1058 {
1059     jvmtiError error;
1060 
1061     error = FUNC_PTR(gdata->jvmti,RawMonitorExit)
1062                 (gdata->jvmti, monitor);
1063     error = ignore_vm_death(error);
1064     if (error != JVMTI_ERROR_NONE) {
1065         EXIT_ERROR(error, "on raw monitor exit");
1066     }
1067 }
1068 
1069 void
1070 debugMonitorWait(jrawMonitorID monitor)
1071 {
1072     jvmtiError error;
1073     error = FUNC_PTR(gdata->jvmti,RawMonitorWait)
1074         (gdata->jvmti, monitor, ((jlong)(-1)));
1075 
1076     /*
1077      * According to the JLS (17.8), here we have
1078      * either :
1079      * a- been notified
1080      * b- gotten a suprious wakeup
1081      * c- been interrupted
1082      * If both a and c have happened, the VM must choose
1083      * which way to return - a or c.  If it chooses c
1084      * then the notify is gone - either to some other
1085      * thread that is also waiting, or it is dropped
1086      * on the floor.
1087      *
1088      * a is what we expect.  b won't hurt us any -
1089      * callers should be programmed to handle
1090      * spurious wakeups.  In case of c,
1091      * then the interrupt has been cleared, but
1092      * we don't want to consume it.  It came from
1093      * user code and is intended for user code, not us.
1094      * So, we will remember that the interrupt has
1095      * occurred and re-activate it when this thread
1096      * goes back into user code.
1097      * That being said, what do we do here?  Since
1098      * we could have been notified too, here we will
1099      * just pretend that we have been.  It won't hurt
1100      * anything to return in the same way as if
1101      * we were notified since callers have to be able to
1102      * handle spurious wakeups anyway.
1103      */
1104     if (error == JVMTI_ERROR_INTERRUPT) {
1105         handleInterrupt();
1106         error = JVMTI_ERROR_NONE;
1107     }
1108     error = ignore_vm_death(error);
1109     if (error != JVMTI_ERROR_NONE) {
1110         EXIT_ERROR(error, "on raw monitor wait");
1111     }
1112 }
1113 
1114 void
1115 debugMonitorTimedWait(jrawMonitorID monitor, jlong millis)
1116 {
1117     jvmtiError error;
1118     error = FUNC_PTR(gdata->jvmti,RawMonitorWait)
1119         (gdata->jvmti, monitor, millis);
1120     if (error == JVMTI_ERROR_INTERRUPT) {
1121         /* See comment above */
1122         handleInterrupt();
1123         error = JVMTI_ERROR_NONE;
1124     }
1125     error = ignore_vm_death(error);
1126     if (error != JVMTI_ERROR_NONE) {
1127         EXIT_ERROR(error, "on raw monitor timed wait");
1128     }
1129 }
1130 
1131 void
1132 debugMonitorNotify(jrawMonitorID monitor)
1133 {
1134     jvmtiError error;
1135 
1136     error = FUNC_PTR(gdata->jvmti,RawMonitorNotify)
1137                 (gdata->jvmti, monitor);
1138     error = ignore_vm_death(error);
1139     if (error != JVMTI_ERROR_NONE) {
1140         EXIT_ERROR(error, "on raw monitor notify");
1141     }
1142 }
1143 
1144 void
1145 debugMonitorNotifyAll(jrawMonitorID monitor)
1146 {
1147     jvmtiError error;
1148 
1149     error = FUNC_PTR(gdata->jvmti,RawMonitorNotifyAll)
1150                 (gdata->jvmti, monitor);
1151     error = ignore_vm_death(error);
1152     if (error != JVMTI_ERROR_NONE) {
1153         EXIT_ERROR(error, "on raw monitor notify all");
1154     }
1155 }
1156 
1157 jrawMonitorID
1158 debugMonitorCreate(char *name)
1159 {
1160     jrawMonitorID monitor;
1161     jvmtiError error;
1162 
1163     error = FUNC_PTR(gdata->jvmti,CreateRawMonitor)
1164                 (gdata->jvmti, name, &monitor);
1165     if (error != JVMTI_ERROR_NONE) {
1166         EXIT_ERROR(error, "on creation of a raw monitor");
1167     }
1168     return monitor;
1169 }
1170 
1171 void
1172 debugMonitorDestroy(jrawMonitorID monitor)
1173 {
1174     jvmtiError error;
1175 
1176     error = FUNC_PTR(gdata->jvmti,DestroyRawMonitor)
1177                 (gdata->jvmti, monitor);
1178     error = ignore_vm_death(error);
1179     if (error != JVMTI_ERROR_NONE) {
1180         EXIT_ERROR(error, "on destruction of raw monitor");
1181     }
1182 }
1183 
1184 /**
1185  * Return array of all threads (must be inside a WITH_LOCAL_REFS)
1186  */
1187 jthread *
1188 allThreads(jint *count)
1189 {
1190     jthread *threads;
1191     jvmtiError error;
1192 
1193     *count = 0;
1194     threads = NULL;
1195     error = JVMTI_FUNC_PTR(gdata->jvmti,GetAllThreads)
1196                 (gdata->jvmti, count, &threads);
1197     if (error == AGENT_ERROR_OUT_OF_MEMORY) {
1198         return NULL; /* Let caller deal with no memory? */
1199     }
1200     if (error != JVMTI_ERROR_NONE) {
1201         EXIT_ERROR(error, "getting all threads");
1202     }
1203     return threads;
1204 }
1205 
1206 /**
1207  * Fill the passed in structure with thread group info.
1208  * name field is JVMTI allocated.  parent is global ref.
1209  */
1210 void
1211 threadGroupInfo(jthreadGroup group, jvmtiThreadGroupInfo *info)
1212 {
1213     jvmtiError error;
1214 
1215     error = JVMTI_FUNC_PTR(gdata->jvmti,GetThreadGroupInfo)
1216                 (gdata->jvmti, group, info);
1217     if (error != JVMTI_ERROR_NONE) {
1218         EXIT_ERROR(error, "on getting thread group info");
1219     }
1220 }
1221 
1222 /**
1223  * Return class signature string
1224  */
1225 jvmtiError
1226 classSignature(jclass clazz, char **psignature, char **pgeneric_signature)
1227 {
1228     jvmtiError error;
1229     char *signature = NULL;
1230 
1231     /*
1232      * pgeneric_signature can be NULL, and GetClassSignature
1233      * accepts NULL.
1234      */
1235     error = FUNC_PTR(gdata->jvmti,GetClassSignature)
1236                 (gdata->jvmti, clazz, &signature, pgeneric_signature);
1237 
1238     if ( psignature != NULL ) {
1239         *psignature = signature;
1240     } else if ( signature != NULL )  {
1241         jvmtiDeallocate(signature);
1242     }
1243     return error;
1244 }
1245 
1246 /* Get class name (not signature) */
1247 char *
1248 getClassname(jclass clazz)
1249 {
1250     char *classname;
1251 
1252     classname = NULL;
1253     if ( clazz != NULL ) {
1254         if (classSignature(clazz, &classname, NULL) != JVMTI_ERROR_NONE) {
1255             classname = NULL;
1256         } else {
1257             /* Convert in place */
1258             convertSignatureToClassname(classname);
1259         }
1260     }
1261     return classname; /* Caller must free this memory */
1262 }
1263 
1264 void
1265 writeGenericSignature(PacketOutputStream *out, char *genericSignature)
1266 {
1267     if (genericSignature == NULL) {
1268         (void)outStream_writeString(out, "");
1269     } else {
1270         (void)outStream_writeString(out, genericSignature);
1271     }
1272 }
1273 
1274 jint
1275 classStatus(jclass clazz)
1276 {
1277     jint status;
1278     jvmtiError error;
1279 
1280     error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassStatus)
1281                 (gdata->jvmti, clazz, &status);
1282     if (error != JVMTI_ERROR_NONE) {
1283         EXIT_ERROR(error, "on getting class status");
1284     }
1285     return status;
1286 }
1287 
1288 static jboolean
1289 isArrayClass(jclass clazz)
1290 {
1291     jboolean isArray = JNI_FALSE;
1292     jvmtiError error;
1293 
1294     error = JVMTI_FUNC_PTR(gdata->jvmti,IsArrayClass)
1295                 (gdata->jvmti, clazz, &isArray);
1296     if (error != JVMTI_ERROR_NONE) {
1297         EXIT_ERROR(error, "on checking for an array class");
1298     }
1299     return isArray;
1300 }
1301 
1302 static jboolean
1303 isInterface(jclass clazz)
1304 {
1305     jboolean isInterface = JNI_FALSE;
1306     jvmtiError error;
1307 
1308     error = JVMTI_FUNC_PTR(gdata->jvmti,IsInterface)
1309                 (gdata->jvmti, clazz, &isInterface);
1310     if (error != JVMTI_ERROR_NONE) {
1311         EXIT_ERROR(error, "on checking for an interface");
1312     }
1313     return isInterface;
1314 }
1315 
1316 jvmtiError
1317 isFieldSynthetic(jclass clazz, jfieldID field, jboolean *psynthetic)
1318 {
1319     jvmtiError error;
1320 
1321     error = JVMTI_FUNC_PTR(gdata->jvmti,IsFieldSynthetic)
1322                 (gdata->jvmti, clazz, field, psynthetic);
1323     if ( error == JVMTI_ERROR_MUST_POSSESS_CAPABILITY ) {
1324         /* If the query is not supported, we assume it is not synthetic. */
1325         *psynthetic = JNI_FALSE;
1326         return JVMTI_ERROR_NONE;
1327     }
1328     return error;
1329 }
1330 
1331 jvmtiError
1332 isMethodSynthetic(jmethodID method, jboolean *psynthetic)
1333 {
1334     jvmtiError error;
1335 
1336     error = JVMTI_FUNC_PTR(gdata->jvmti,IsMethodSynthetic)
1337                 (gdata->jvmti, method, psynthetic);
1338     if ( error == JVMTI_ERROR_MUST_POSSESS_CAPABILITY ) {
1339         /* If the query is not supported, we assume it is not synthetic. */
1340         *psynthetic = JNI_FALSE;
1341         return JVMTI_ERROR_NONE;
1342     }
1343     return error;
1344 }
1345 
1346 jboolean
1347 isMethodNative(jmethodID method)
1348 {
1349     jboolean isNative = JNI_FALSE;
1350     jvmtiError error;
1351 
1352     error = JVMTI_FUNC_PTR(gdata->jvmti,IsMethodNative)
1353                 (gdata->jvmti, method, &isNative);
1354     if (error != JVMTI_ERROR_NONE) {
1355         EXIT_ERROR(error, "on checking for a native interface");
1356     }
1357     return isNative;
1358 }
1359 
1360 jboolean
1361 isSameObject(JNIEnv *env, jobject o1, jobject o2)
1362 {
1363     if ( o1==o2 ) {
1364         return JNI_TRUE;
1365     }
1366     return FUNC_PTR(env,IsSameObject)(env, o1, o2);
1367 }
1368 
1369 jint
1370 objectHashCode(jobject object)
1371 {
1372     jint hashCode = 0;
1373     jvmtiError error;
1374 
1375     if ( object!=NULL ) {
1376         error = JVMTI_FUNC_PTR(gdata->jvmti,GetObjectHashCode)
1377                     (gdata->jvmti, object, &hashCode);
1378         if (error != JVMTI_ERROR_NONE) {
1379             EXIT_ERROR(error, "on getting an object hash code");
1380         }
1381     }
1382     return hashCode;
1383 }
1384 
1385 /* Get all implemented interfaces (must be inside a WITH_LOCAL_REFS) */
1386 jvmtiError
1387 allInterfaces(jclass clazz, jclass **ppinterfaces, jint *pcount)
1388 {
1389     jvmtiError error;
1390 
1391     *pcount = 0;
1392     *ppinterfaces = NULL;
1393     error = JVMTI_FUNC_PTR(gdata->jvmti,GetImplementedInterfaces)
1394                 (gdata->jvmti, clazz, pcount, ppinterfaces);
1395     return error;
1396 }
1397 
1398 /* Get all loaded classes (must be inside a WITH_LOCAL_REFS) */
1399 jvmtiError
1400 allLoadedClasses(jclass **ppclasses, jint *pcount)
1401 {
1402     jvmtiError error;
1403 
1404     *pcount = 0;
1405     *ppclasses = NULL;
1406     error = JVMTI_FUNC_PTR(gdata->jvmti,GetLoadedClasses)
1407                 (gdata->jvmti, pcount, ppclasses);
1408     return error;
1409 }
1410 
1411 /* Get all loaded classes for a loader (must be inside a WITH_LOCAL_REFS) */
1412 jvmtiError
1413 allClassLoaderClasses(jobject loader, jclass **ppclasses, jint *pcount)
1414 {
1415     jvmtiError error;
1416 
1417     *pcount = 0;
1418     *ppclasses = NULL;
1419     error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassLoaderClasses)
1420                 (gdata->jvmti, loader, pcount, ppclasses);
1421     return error;
1422 }
1423 
1424 static jboolean
1425 is_a_nested_class(char *outer_sig, int outer_sig_len, char *sig, int sep)
1426 {
1427     char *inner;
1428 
1429     /* Assumed outer class signature is  "LOUTERCLASSNAME;"
1430      *         inner class signature is  "LOUTERCLASSNAME$INNERNAME;"
1431      *
1432      * INNERNAME can take the form:
1433      *    [0-9][1-9]*        anonymous class somewhere in the file
1434      *    [0-9][1-9]*NAME    local class somewhere in the OUTER class
1435      *    NAME               nested class in OUTER
1436      *
1437      * If NAME itself contains a $ (sep) then classname is further nested
1438      *    inside another class.
1439      *
1440      */
1441 
1442     /* Check prefix first */
1443     if ( strncmp(sig, outer_sig, outer_sig_len-1) != 0 ) {
1444         return JNI_FALSE;
1445     }
1446 
1447     /* Prefix must be followed by a $ (sep) */
1448     if ( sig[outer_sig_len-1] != sep ) {
1449         return JNI_FALSE;  /* No sep follows the match, must not be nested. */
1450     }
1451 
1452     /* Walk past any digits, if we reach the end, must be pure anonymous */
1453     inner = sig + outer_sig_len;
1454 #if 1 /* We want to return local classes */
1455     while ( *inner && isdigit(*inner) ) {
1456         inner++;
1457     }
1458     /* But anonymous class names can't be trusted. */
1459     if ( *inner == ';' ) {
1460         return JNI_FALSE;  /* A pure anonymous class */
1461     }
1462 #else
1463     if ( *inner && isdigit(*inner) ) {
1464         return JNI_FALSE;  /* A pure anonymous or local class */
1465     }
1466 #endif
1467 
1468     /* Nested deeper? */
1469     if ( strchr(inner, sep) != NULL ) {
1470         return JNI_FALSE;  /* Nested deeper than we want? */
1471     }
1472     return JNI_TRUE;
1473 }
1474 
1475 /* Get all nested classes for a class (must be inside a WITH_LOCAL_REFS) */
1476 jvmtiError
1477 allNestedClasses(jclass parent_clazz, jclass **ppnested, jint *pcount)
1478 {
1479     jvmtiError error;
1480     jobject parent_loader;
1481     jclass *classes;
1482     char *signature;
1483     size_t len;
1484     jint count;
1485     jint ncount;
1486     int i;
1487 
1488     *ppnested   = NULL;
1489     *pcount     = 0;
1490 
1491     parent_loader = NULL;
1492     classes       = NULL;
1493     signature     = NULL;
1494     count         = 0;
1495     ncount        = 0;
1496 
1497     error = classLoader(parent_clazz, &parent_loader);
1498     if (error != JVMTI_ERROR_NONE) {
1499         return error;
1500     }
1501     error = classSignature(parent_clazz, &signature, NULL);
1502     if (error != JVMTI_ERROR_NONE) {
1503         return error;
1504     }
1505     len = strlen(signature);
1506 
1507     error = allClassLoaderClasses(parent_loader, &classes, &count);
1508     if ( error != JVMTI_ERROR_NONE ) {
1509         jvmtiDeallocate(signature);
1510         return error;
1511     }
1512 
1513     for (i=0; i<count; i++) {
1514         jclass clazz;
1515         char *candidate_signature;
1516 
1517         clazz = classes[i];
1518         candidate_signature = NULL;
1519         error = classSignature(clazz, &candidate_signature, NULL);
1520         if (error != JVMTI_ERROR_NONE) {
1521             break;
1522         }
1523 
1524         if ( is_a_nested_class(signature, (int)len, candidate_signature, '$') ||
1525              is_a_nested_class(signature, (int)len, candidate_signature, '#') ) {
1526             /* Float nested classes to top */
1527             classes[i] = classes[ncount];
1528             classes[ncount++] = clazz;
1529         }
1530         jvmtiDeallocate(candidate_signature);
1531     }
1532 
1533     jvmtiDeallocate(signature);
1534 
1535     if ( count != 0 &&  ncount == 0 ) {
1536         jvmtiDeallocate(classes);
1537         classes = NULL;
1538     }
1539 
1540     *ppnested = classes;
1541     *pcount = ncount;
1542     return error;
1543 }
1544 
1545 void
1546 createLocalRefSpace(JNIEnv *env, jint capacity)
1547 {
1548     /*
1549      * Save current exception since it might get overwritten by
1550      * the calls below. Note we must depend on space in the existing
1551      * frame because asking for a new frame may generate an exception.
1552      */
1553     jobject throwable = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
1554 
1555     /*
1556      * Use the current frame if necessary; otherwise create a new one
1557      */
1558     if (JNI_FUNC_PTR(env,PushLocalFrame)(env, capacity) < 0) {
1559         EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"PushLocalFrame: Unable to push JNI frame");
1560     }
1561 
1562     /*
1563      * TO DO: This could be more efficient if it used EnsureLocalCapacity,
1564      * but that would not work if two functions on the call stack
1565      * use this function. We would need to either track reserved
1566      * references on a per-thread basis or come up with a convention
1567      * that would prevent two functions from depending on this function
1568      * at the same time.
1569      */
1570 
1571     /*
1572      * Restore exception state from before call
1573      */
1574     if (throwable != NULL) {
1575         JNI_FUNC_PTR(env,Throw)(env, throwable);
1576     } else {
1577         JNI_FUNC_PTR(env,ExceptionClear)(env);
1578     }
1579 }
1580 
1581 jboolean
1582 isClass(jobject object)
1583 {
1584     JNIEnv *env = getEnv();
1585     return JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->classClass);
1586 }
1587 
1588 jboolean
1589 isThread(jobject object)
1590 {
1591     JNIEnv *env = getEnv();
1592     return JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->threadClass);
1593 }
1594 
1595 jboolean
1596 isThreadGroup(jobject object)
1597 {
1598     JNIEnv *env = getEnv();
1599     return JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->threadGroupClass);
1600 }
1601 
1602 jboolean
1603 isString(jobject object)
1604 {
1605     JNIEnv *env = getEnv();
1606     return JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->stringClass);
1607 }
1608 
1609 jboolean
1610 isClassLoader(jobject object)
1611 {
1612     JNIEnv *env = getEnv();
1613     return JNI_FUNC_PTR(env,IsInstanceOf)(env, object, gdata->classLoaderClass);
1614 }
1615 
1616 jboolean
1617 isArray(jobject object)
1618 {
1619     JNIEnv *env = getEnv();
1620     jboolean is;
1621 
1622     WITH_LOCAL_REFS(env, 1) {
1623         jclass clazz;
1624         clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, object);
1625         is = isArrayClass(clazz);
1626     } END_WITH_LOCAL_REFS(env);
1627 
1628     return is;
1629 }
1630 
1631 /**
1632  * Return property value as jstring
1633  */
1634 static jstring
1635 getPropertyValue(JNIEnv *env, char *propertyName)
1636 {
1637     jstring valueString;
1638     jstring nameString;
1639 
1640     valueString = NULL;
1641 
1642     /* Create new String object to hold the property name */
1643     nameString = JNI_FUNC_PTR(env,NewStringUTF)(env, propertyName);
1644     if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
1645         JNI_FUNC_PTR(env,ExceptionClear)(env);
1646         /* NULL will be returned below */
1647     } else {
1648         /* Call valueString = System.getProperty(nameString) */
1649         valueString = JNI_FUNC_PTR(env,CallStaticObjectMethod)
1650             (env, gdata->systemClass, gdata->systemGetProperty, nameString);
1651         if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
1652             JNI_FUNC_PTR(env,ExceptionClear)(env);
1653             valueString = NULL;
1654         }
1655     }
1656     return valueString;
1657 }
1658 
1659 /**
1660  * Set an agent property
1661  */
1662 void
1663 setAgentPropertyValue(JNIEnv *env, char *propertyName, char* propertyValue)
1664 {
1665     jstring nameString;
1666     jstring valueString;
1667 
1668     if (gdata->agent_properties == NULL) {
1669         /* VMSupport doesn't exist; so ignore */
1670         return;
1671     }
1672 
1673     /* Create jstrings for property name and value */
1674     nameString = JNI_FUNC_PTR(env,NewStringUTF)(env, propertyName);
1675     if (nameString != NULL) {
1676         valueString = JNU_NewStringPlatform(env, propertyValue);
1677         if (valueString != NULL) {
1678             /* invoke Properties.setProperty */
1679             JNI_FUNC_PTR(env,CallObjectMethod)
1680                 (env, gdata->agent_properties,
1681                  gdata->setProperty,
1682                  nameString, valueString);
1683         }
1684     }
1685     if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
1686         JNI_FUNC_PTR(env,ExceptionClear)(env);
1687     }
1688 }
1689 
1690 /**
1691  * Return property value as JDWP allocated string in UTF8 encoding
1692  */
1693 static char *
1694 getPropertyUTF8(JNIEnv *env, char *propertyName)
1695 {
1696     jvmtiError  error;
1697     char       *value;
1698 
1699     value = NULL;
1700     error = JVMTI_FUNC_PTR(gdata->jvmti,GetSystemProperty)
1701                 (gdata->jvmti, (const char *)propertyName, &value);
1702     if (error != JVMTI_ERROR_NONE) {
1703         jstring valueString;
1704 
1705         value = NULL;
1706         valueString = getPropertyValue(env, propertyName);
1707 
1708         if (valueString != NULL) {
1709             const char *utf;
1710 
1711             /* Get the UTF8 encoding for this property value string */
1712             utf = JNI_FUNC_PTR(env,GetStringUTFChars)(env, valueString, NULL);
1713             /* Make a copy for returning, release the JNI copy */
1714             value = jvmtiAllocate((int)strlen(utf) + 1);
1715             if (value != NULL) {
1716                 (void)strcpy(value, utf);
1717             }
1718             JNI_FUNC_PTR(env,ReleaseStringUTFChars)(env, valueString, utf);
1719         }
1720     }
1721     if ( value == NULL ) {
1722         ERROR_MESSAGE(("JDWP Can't get property value for %s", propertyName));
1723         EXIT_ERROR(AGENT_ERROR_NULL_POINTER,NULL);
1724     }
1725     return value;
1726 }
1727 
1728 jboolean
1729 isMethodObsolete(jmethodID method)
1730 {
1731     jvmtiError error;
1732     jboolean obsolete = JNI_TRUE;
1733 
1734     if ( method != NULL ) {
1735         error = JVMTI_FUNC_PTR(gdata->jvmti,IsMethodObsolete)
1736                     (gdata->jvmti, method, &obsolete);
1737         if (error != JVMTI_ERROR_NONE) {
1738             obsolete = JNI_TRUE;
1739         }
1740     }
1741     return obsolete;
1742 }
1743 
1744 /* Get the jvmti environment to be used with tags */
1745 jvmtiEnv *
1746 getSpecialJvmti(void)
1747 {
1748     jvmtiEnv  *jvmti;
1749     jvmtiError error;
1750     int        rc;
1751 
1752     /* Get one time use JVMTI Env */
1753     jvmtiCapabilities caps;
1754 
1755     rc = JVM_FUNC_PTR(gdata->jvm,GetEnv)
1756                      (gdata->jvm, (void **)&jvmti, JVMTI_VERSION_1);
1757     if (rc != JNI_OK) {
1758         return NULL;
1759     }
1760     (void)memset(&caps, 0, (int)sizeof(caps));
1761     caps.can_tag_objects = 1;
1762     error = JVMTI_FUNC_PTR(jvmti,AddCapabilities)(jvmti, &caps);
1763     if ( error != JVMTI_ERROR_NONE ) {
1764         return NULL;
1765     }
1766     return jvmti;
1767 }
1768 
1769 void
1770 writeCodeLocation(PacketOutputStream *out, jclass clazz,
1771                        jmethodID method, jlocation location)
1772 {
1773     jbyte tag;
1774 
1775     if (clazz != NULL) {
1776         tag = referenceTypeTag(clazz);
1777     } else {
1778         tag = JDWP_TYPE_TAG(CLASS);
1779     }
1780     (void)outStream_writeByte(out, tag);
1781     (void)outStream_writeObjectRef(getEnv(), out, clazz);
1782     (void)outStream_writeMethodID(out, isMethodObsolete(method)?NULL:method);
1783     (void)outStream_writeLocation(out, location);
1784 }
1785 
1786 void *
1787 jvmtiAllocate(jint numBytes)
1788 {
1789     void *ptr;
1790     jvmtiError error;
1791     if ( numBytes == 0 ) {
1792         return NULL;
1793     }
1794     error = FUNC_PTR(gdata->jvmti,Allocate)
1795                 (gdata->jvmti, numBytes, (unsigned char**)&ptr);
1796     if (error != JVMTI_ERROR_NONE ) {
1797         EXIT_ERROR(error, "Can't allocate jvmti memory");
1798     }
1799     return ptr;
1800 }
1801 
1802 void
1803 jvmtiDeallocate(void *ptr)
1804 {
1805     jvmtiError error;
1806     if ( ptr == NULL ) {
1807         return;
1808     }
1809     error = FUNC_PTR(gdata->jvmti,Deallocate)
1810                 (gdata->jvmti, ptr);
1811     if (error != JVMTI_ERROR_NONE ) {
1812         EXIT_ERROR(error, "Can't deallocate jvmti memory");
1813     }
1814 }
1815 
1816 /* Rarely needed, transport library uses JDWP errors, only use? */
1817 jvmtiError
1818 map2jvmtiError(jdwpError error)
1819 {
1820     switch ( error ) {
1821         case JDWP_ERROR(NONE):
1822             return JVMTI_ERROR_NONE;
1823         case JDWP_ERROR(INVALID_THREAD):
1824             return JVMTI_ERROR_INVALID_THREAD;
1825         case JDWP_ERROR(INVALID_THREAD_GROUP):
1826             return JVMTI_ERROR_INVALID_THREAD_GROUP;
1827         case JDWP_ERROR(INVALID_PRIORITY):
1828             return JVMTI_ERROR_INVALID_PRIORITY;
1829         case JDWP_ERROR(THREAD_NOT_SUSPENDED):
1830             return JVMTI_ERROR_THREAD_NOT_SUSPENDED;
1831         case JDWP_ERROR(THREAD_SUSPENDED):
1832             return JVMTI_ERROR_THREAD_SUSPENDED;
1833         case JDWP_ERROR(INVALID_OBJECT):
1834             return JVMTI_ERROR_INVALID_OBJECT;
1835         case JDWP_ERROR(INVALID_CLASS):
1836             return JVMTI_ERROR_INVALID_CLASS;
1837         case JDWP_ERROR(CLASS_NOT_PREPARED):
1838             return JVMTI_ERROR_CLASS_NOT_PREPARED;
1839         case JDWP_ERROR(INVALID_METHODID):
1840             return JVMTI_ERROR_INVALID_METHODID;
1841         case JDWP_ERROR(INVALID_LOCATION):
1842             return JVMTI_ERROR_INVALID_LOCATION;
1843         case JDWP_ERROR(INVALID_FIELDID):
1844             return JVMTI_ERROR_INVALID_FIELDID;
1845         case JDWP_ERROR(INVALID_FRAMEID):
1846             return AGENT_ERROR_INVALID_FRAMEID;
1847         case JDWP_ERROR(NO_MORE_FRAMES):
1848             return JVMTI_ERROR_NO_MORE_FRAMES;
1849         case JDWP_ERROR(OPAQUE_FRAME):
1850             return JVMTI_ERROR_OPAQUE_FRAME;
1851         case JDWP_ERROR(NOT_CURRENT_FRAME):
1852             return AGENT_ERROR_NOT_CURRENT_FRAME;
1853         case JDWP_ERROR(TYPE_MISMATCH):
1854             return JVMTI_ERROR_TYPE_MISMATCH;
1855         case JDWP_ERROR(INVALID_SLOT):
1856             return JVMTI_ERROR_INVALID_SLOT;
1857         case JDWP_ERROR(DUPLICATE):
1858             return JVMTI_ERROR_DUPLICATE;
1859         case JDWP_ERROR(NOT_FOUND):
1860             return JVMTI_ERROR_NOT_FOUND;
1861         case JDWP_ERROR(INVALID_MONITOR):
1862             return JVMTI_ERROR_INVALID_MONITOR;
1863         case JDWP_ERROR(NOT_MONITOR_OWNER):
1864             return JVMTI_ERROR_NOT_MONITOR_OWNER;
1865         case JDWP_ERROR(INTERRUPT):
1866             return JVMTI_ERROR_INTERRUPT;
1867         case JDWP_ERROR(INVALID_CLASS_FORMAT):
1868             return JVMTI_ERROR_INVALID_CLASS_FORMAT;
1869         case JDWP_ERROR(CIRCULAR_CLASS_DEFINITION):
1870             return JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION;
1871         case JDWP_ERROR(FAILS_VERIFICATION):
1872             return JVMTI_ERROR_FAILS_VERIFICATION;
1873         case JDWP_ERROR(ADD_METHOD_NOT_IMPLEMENTED):
1874             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED;
1875         case JDWP_ERROR(SCHEMA_CHANGE_NOT_IMPLEMENTED):
1876             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
1877         case JDWP_ERROR(INVALID_TYPESTATE):
1878             return JVMTI_ERROR_INVALID_TYPESTATE;
1879         case JDWP_ERROR(HIERARCHY_CHANGE_NOT_IMPLEMENTED):
1880             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;
1881         case JDWP_ERROR(DELETE_METHOD_NOT_IMPLEMENTED):
1882             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;
1883         case JDWP_ERROR(UNSUPPORTED_VERSION):
1884             return JVMTI_ERROR_UNSUPPORTED_VERSION;
1885         case JDWP_ERROR(NAMES_DONT_MATCH):
1886             return JVMTI_ERROR_NAMES_DONT_MATCH;
1887         case JDWP_ERROR(CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED):
1888             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED;
1889         case JDWP_ERROR(METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED):
1890             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED;
1891         case JDWP_ERROR(CLASS_ATTRIBUTE_CHANGE_NOT_IMPLEMENTED):
1892             return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
1893         case JDWP_ERROR(NOT_IMPLEMENTED):
1894             return JVMTI_ERROR_NOT_AVAILABLE;
1895         case JDWP_ERROR(NULL_POINTER):
1896             return JVMTI_ERROR_NULL_POINTER;
1897         case JDWP_ERROR(ABSENT_INFORMATION):
1898             return JVMTI_ERROR_ABSENT_INFORMATION;
1899         case JDWP_ERROR(INVALID_EVENT_TYPE):
1900             return JVMTI_ERROR_INVALID_EVENT_TYPE;
1901         case JDWP_ERROR(ILLEGAL_ARGUMENT):
1902             return JVMTI_ERROR_ILLEGAL_ARGUMENT;
1903         case JDWP_ERROR(OUT_OF_MEMORY):
1904             return JVMTI_ERROR_OUT_OF_MEMORY;
1905         case JDWP_ERROR(ACCESS_DENIED):
1906             return JVMTI_ERROR_ACCESS_DENIED;
1907         case JDWP_ERROR(VM_DEAD):
1908             return JVMTI_ERROR_WRONG_PHASE;
1909         case JDWP_ERROR(UNATTACHED_THREAD):
1910             return JVMTI_ERROR_UNATTACHED_THREAD;
1911         case JDWP_ERROR(INVALID_TAG):
1912             return AGENT_ERROR_INVALID_TAG;
1913         case JDWP_ERROR(ALREADY_INVOKING):
1914             return AGENT_ERROR_ALREADY_INVOKING;
1915         case JDWP_ERROR(INVALID_INDEX):
1916             return AGENT_ERROR_INVALID_INDEX;
1917         case JDWP_ERROR(INVALID_LENGTH):
1918             return AGENT_ERROR_INVALID_LENGTH;
1919         case JDWP_ERROR(INVALID_STRING):
1920             return AGENT_ERROR_INVALID_STRING;
1921         case JDWP_ERROR(INVALID_CLASS_LOADER):
1922             return AGENT_ERROR_INVALID_CLASS_LOADER;
1923         case JDWP_ERROR(INVALID_ARRAY):
1924             return AGENT_ERROR_INVALID_ARRAY;
1925         case JDWP_ERROR(TRANSPORT_LOAD):
1926             return AGENT_ERROR_TRANSPORT_LOAD;
1927         case JDWP_ERROR(TRANSPORT_INIT):
1928             return AGENT_ERROR_TRANSPORT_INIT;
1929         case JDWP_ERROR(NATIVE_METHOD):
1930             return AGENT_ERROR_NATIVE_METHOD;
1931         case JDWP_ERROR(INVALID_COUNT):
1932             return AGENT_ERROR_INVALID_COUNT;
1933         case JDWP_ERROR(INTERNAL):
1934             return AGENT_ERROR_JDWP_INTERNAL;
1935     }
1936     return AGENT_ERROR_INTERNAL;
1937 }
1938 
1939 static jvmtiEvent index2jvmti[EI_max-EI_min+1];
1940 static jdwpEvent  index2jdwp [EI_max-EI_min+1];
1941 
1942 void
1943 eventIndexInit(void)
1944 {
1945     (void)memset(index2jvmti, 0, (int)sizeof(index2jvmti));
1946     (void)memset(index2jdwp,  0, (int)sizeof(index2jdwp));
1947 
1948     index2jvmti[EI_SINGLE_STEP        -EI_min] = JVMTI_EVENT_SINGLE_STEP;
1949     index2jvmti[EI_BREAKPOINT         -EI_min] = JVMTI_EVENT_BREAKPOINT;
1950     index2jvmti[EI_FRAME_POP          -EI_min] = JVMTI_EVENT_FRAME_POP;
1951     index2jvmti[EI_EXCEPTION          -EI_min] = JVMTI_EVENT_EXCEPTION;
1952     index2jvmti[EI_THREAD_START       -EI_min] = JVMTI_EVENT_THREAD_START;
1953     index2jvmti[EI_THREAD_END         -EI_min] = JVMTI_EVENT_THREAD_END;
1954     index2jvmti[EI_CLASS_PREPARE      -EI_min] = JVMTI_EVENT_CLASS_PREPARE;
1955     index2jvmti[EI_GC_FINISH          -EI_min] = JVMTI_EVENT_GARBAGE_COLLECTION_FINISH;
1956     index2jvmti[EI_CLASS_LOAD         -EI_min] = JVMTI_EVENT_CLASS_LOAD;
1957     index2jvmti[EI_FIELD_ACCESS       -EI_min] = JVMTI_EVENT_FIELD_ACCESS;
1958     index2jvmti[EI_FIELD_MODIFICATION -EI_min] = JVMTI_EVENT_FIELD_MODIFICATION;
1959     index2jvmti[EI_EXCEPTION_CATCH    -EI_min] = JVMTI_EVENT_EXCEPTION_CATCH;
1960     index2jvmti[EI_METHOD_ENTRY       -EI_min] = JVMTI_EVENT_METHOD_ENTRY;
1961     index2jvmti[EI_METHOD_EXIT        -EI_min] = JVMTI_EVENT_METHOD_EXIT;
1962     index2jvmti[EI_MONITOR_CONTENDED_ENTER      -EI_min] = JVMTI_EVENT_MONITOR_CONTENDED_ENTER;
1963     index2jvmti[EI_MONITOR_CONTENDED_ENTERED    -EI_min] = JVMTI_EVENT_MONITOR_CONTENDED_ENTERED;
1964     index2jvmti[EI_MONITOR_WAIT       -EI_min] = JVMTI_EVENT_MONITOR_WAIT;
1965     index2jvmti[EI_MONITOR_WAITED     -EI_min] = JVMTI_EVENT_MONITOR_WAITED;
1966     index2jvmti[EI_VM_INIT            -EI_min] = JVMTI_EVENT_VM_INIT;
1967     index2jvmti[EI_VM_DEATH           -EI_min] = JVMTI_EVENT_VM_DEATH;
1968 
1969     index2jdwp[EI_SINGLE_STEP         -EI_min] = JDWP_EVENT(SINGLE_STEP);
1970     index2jdwp[EI_BREAKPOINT          -EI_min] = JDWP_EVENT(BREAKPOINT);
1971     index2jdwp[EI_FRAME_POP           -EI_min] = JDWP_EVENT(FRAME_POP);
1972     index2jdwp[EI_EXCEPTION           -EI_min] = JDWP_EVENT(EXCEPTION);
1973     index2jdwp[EI_THREAD_START        -EI_min] = JDWP_EVENT(THREAD_START);
1974     index2jdwp[EI_THREAD_END          -EI_min] = JDWP_EVENT(THREAD_END);
1975     index2jdwp[EI_CLASS_PREPARE       -EI_min] = JDWP_EVENT(CLASS_PREPARE);
1976     index2jdwp[EI_GC_FINISH           -EI_min] = JDWP_EVENT(CLASS_UNLOAD);
1977     index2jdwp[EI_CLASS_LOAD          -EI_min] = JDWP_EVENT(CLASS_LOAD);
1978     index2jdwp[EI_FIELD_ACCESS        -EI_min] = JDWP_EVENT(FIELD_ACCESS);
1979     index2jdwp[EI_FIELD_MODIFICATION  -EI_min] = JDWP_EVENT(FIELD_MODIFICATION);
1980     index2jdwp[EI_EXCEPTION_CATCH     -EI_min] = JDWP_EVENT(EXCEPTION_CATCH);
1981     index2jdwp[EI_METHOD_ENTRY        -EI_min] = JDWP_EVENT(METHOD_ENTRY);
1982     index2jdwp[EI_METHOD_EXIT         -EI_min] = JDWP_EVENT(METHOD_EXIT);
1983     index2jdwp[EI_MONITOR_CONTENDED_ENTER             -EI_min] = JDWP_EVENT(MONITOR_CONTENDED_ENTER);
1984     index2jdwp[EI_MONITOR_CONTENDED_ENTERED           -EI_min] = JDWP_EVENT(MONITOR_CONTENDED_ENTERED);
1985     index2jdwp[EI_MONITOR_WAIT        -EI_min] = JDWP_EVENT(MONITOR_WAIT);
1986     index2jdwp[EI_MONITOR_WAITED      -EI_min] = JDWP_EVENT(MONITOR_WAITED);
1987     index2jdwp[EI_VM_INIT             -EI_min] = JDWP_EVENT(VM_INIT);
1988     index2jdwp[EI_VM_DEATH            -EI_min] = JDWP_EVENT(VM_DEATH);
1989 }
1990 
1991 jdwpEvent
1992 eventIndex2jdwp(EventIndex i)
1993 {
1994     if ( i < EI_min || i > EI_max ) {
1995         EXIT_ERROR(AGENT_ERROR_INVALID_INDEX,"bad EventIndex");
1996     }
1997     return index2jdwp[i-EI_min];
1998 }
1999 
2000 jvmtiEvent
2001 eventIndex2jvmti(EventIndex i)
2002 {
2003     if ( i < EI_min || i > EI_max ) {
2004         EXIT_ERROR(AGENT_ERROR_INVALID_INDEX,"bad EventIndex");
2005     }
2006     return index2jvmti[i-EI_min];
2007 }
2008 
2009 EventIndex
2010 jdwp2EventIndex(jdwpEvent eventType)
2011 {
2012     switch ( eventType ) {
2013         case JDWP_EVENT(SINGLE_STEP):
2014             return EI_SINGLE_STEP;
2015         case JDWP_EVENT(BREAKPOINT):
2016             return EI_BREAKPOINT;
2017         case JDWP_EVENT(FRAME_POP):
2018             return EI_FRAME_POP;
2019         case JDWP_EVENT(EXCEPTION):
2020             return EI_EXCEPTION;
2021         case JDWP_EVENT(THREAD_START):
2022             return EI_THREAD_START;
2023         case JDWP_EVENT(THREAD_END):
2024             return EI_THREAD_END;
2025         case JDWP_EVENT(CLASS_PREPARE):
2026             return EI_CLASS_PREPARE;
2027         case JDWP_EVENT(CLASS_UNLOAD):
2028             return EI_GC_FINISH;
2029         case JDWP_EVENT(CLASS_LOAD):
2030             return EI_CLASS_LOAD;
2031         case JDWP_EVENT(FIELD_ACCESS):
2032             return EI_FIELD_ACCESS;
2033         case JDWP_EVENT(FIELD_MODIFICATION):
2034             return EI_FIELD_MODIFICATION;
2035         case JDWP_EVENT(EXCEPTION_CATCH):
2036             return EI_EXCEPTION_CATCH;
2037         case JDWP_EVENT(METHOD_ENTRY):
2038             return EI_METHOD_ENTRY;
2039         case JDWP_EVENT(METHOD_EXIT):
2040             return EI_METHOD_EXIT;
2041         case JDWP_EVENT(METHOD_EXIT_WITH_RETURN_VALUE):
2042             return EI_METHOD_EXIT;
2043         case JDWP_EVENT(MONITOR_CONTENDED_ENTER):
2044             return EI_MONITOR_CONTENDED_ENTER;
2045         case JDWP_EVENT(MONITOR_CONTENDED_ENTERED):
2046             return EI_MONITOR_CONTENDED_ENTERED;
2047         case JDWP_EVENT(MONITOR_WAIT):
2048             return EI_MONITOR_WAIT;
2049         case JDWP_EVENT(MONITOR_WAITED):
2050             return EI_MONITOR_WAITED;
2051         case JDWP_EVENT(VM_INIT):
2052             return EI_VM_INIT;
2053         case JDWP_EVENT(VM_DEATH):
2054             return EI_VM_DEATH;
2055         default:
2056             break;
2057     }
2058 
2059     /*
2060      * Event type not recognized - don't exit with error as caller
2061      * may wish to return error to debugger.
2062      */
2063     return (EventIndex)0;
2064 }
2065 
2066 EventIndex
2067 jvmti2EventIndex(jvmtiEvent kind)
2068 {
2069     switch ( kind ) {
2070         case JVMTI_EVENT_SINGLE_STEP:
2071             return EI_SINGLE_STEP;
2072         case JVMTI_EVENT_BREAKPOINT:
2073             return EI_BREAKPOINT;
2074         case JVMTI_EVENT_FRAME_POP:
2075             return EI_FRAME_POP;
2076         case JVMTI_EVENT_EXCEPTION:
2077             return EI_EXCEPTION;
2078         case JVMTI_EVENT_THREAD_START:
2079             return EI_THREAD_START;
2080         case JVMTI_EVENT_THREAD_END:
2081             return EI_THREAD_END;
2082         case JVMTI_EVENT_CLASS_PREPARE:
2083             return EI_CLASS_PREPARE;
2084         case JVMTI_EVENT_GARBAGE_COLLECTION_FINISH:
2085             return EI_GC_FINISH;
2086         case JVMTI_EVENT_CLASS_LOAD:
2087             return EI_CLASS_LOAD;
2088         case JVMTI_EVENT_FIELD_ACCESS:
2089             return EI_FIELD_ACCESS;
2090         case JVMTI_EVENT_FIELD_MODIFICATION:
2091             return EI_FIELD_MODIFICATION;
2092         case JVMTI_EVENT_EXCEPTION_CATCH:
2093             return EI_EXCEPTION_CATCH;
2094         case JVMTI_EVENT_METHOD_ENTRY:
2095             return EI_METHOD_ENTRY;
2096         case JVMTI_EVENT_METHOD_EXIT:
2097             return EI_METHOD_EXIT;
2098         /*
2099          * There is no JVMTI_EVENT_METHOD_EXIT_WITH_RETURN_VALUE.
2100          * The normal JVMTI_EVENT_METHOD_EXIT always contains the return value.
2101          */
2102         case JVMTI_EVENT_MONITOR_CONTENDED_ENTER:
2103             return EI_MONITOR_CONTENDED_ENTER;
2104         case JVMTI_EVENT_MONITOR_CONTENDED_ENTERED:
2105             return EI_MONITOR_CONTENDED_ENTERED;
2106         case JVMTI_EVENT_MONITOR_WAIT:
2107             return EI_MONITOR_WAIT;
2108         case JVMTI_EVENT_MONITOR_WAITED:
2109             return EI_MONITOR_WAITED;
2110         case JVMTI_EVENT_VM_INIT:
2111             return EI_VM_INIT;
2112         case JVMTI_EVENT_VM_DEATH:
2113             return EI_VM_DEATH;
2114         default:
2115             EXIT_ERROR(AGENT_ERROR_INVALID_INDEX,"JVMTI to EventIndex mapping");
2116             break;
2117     }
2118     return (EventIndex)0;
2119 }
2120 
2121 /* This routine is commonly used, maps jvmti and agent errors to the best
2122  *    jdwp error code we can map to.
2123  */
2124 jdwpError
2125 map2jdwpError(jvmtiError error)
2126 {
2127     switch ( (int)error ) {
2128         case JVMTI_ERROR_NONE:
2129             return JDWP_ERROR(NONE);
2130         case AGENT_ERROR_INVALID_THREAD:
2131         case JVMTI_ERROR_INVALID_THREAD:
2132             return JDWP_ERROR(INVALID_THREAD);
2133         case JVMTI_ERROR_INVALID_THREAD_GROUP:
2134             return JDWP_ERROR(INVALID_THREAD_GROUP);
2135         case JVMTI_ERROR_INVALID_PRIORITY:
2136             return JDWP_ERROR(INVALID_PRIORITY);
2137         case JVMTI_ERROR_THREAD_NOT_SUSPENDED:
2138             return JDWP_ERROR(THREAD_NOT_SUSPENDED);
2139         case JVMTI_ERROR_THREAD_SUSPENDED:
2140             return JDWP_ERROR(THREAD_SUSPENDED);
2141         case JVMTI_ERROR_THREAD_NOT_ALIVE:
2142             return JDWP_ERROR(INVALID_THREAD);
2143         case AGENT_ERROR_INVALID_OBJECT:
2144         case JVMTI_ERROR_INVALID_OBJECT:
2145             return JDWP_ERROR(INVALID_OBJECT);
2146         case JVMTI_ERROR_INVALID_CLASS:
2147             return JDWP_ERROR(INVALID_CLASS);
2148         case JVMTI_ERROR_CLASS_NOT_PREPARED:
2149             return JDWP_ERROR(CLASS_NOT_PREPARED);
2150         case JVMTI_ERROR_INVALID_METHODID:
2151             return JDWP_ERROR(INVALID_METHODID);
2152         case JVMTI_ERROR_INVALID_LOCATION:
2153             return JDWP_ERROR(INVALID_LOCATION);
2154         case JVMTI_ERROR_INVALID_FIELDID:
2155             return JDWP_ERROR(INVALID_FIELDID);
2156         case AGENT_ERROR_NO_MORE_FRAMES:
2157         case JVMTI_ERROR_NO_MORE_FRAMES:
2158             return JDWP_ERROR(NO_MORE_FRAMES);
2159         case JVMTI_ERROR_OPAQUE_FRAME:
2160             return JDWP_ERROR(OPAQUE_FRAME);
2161         case JVMTI_ERROR_TYPE_MISMATCH:
2162             return JDWP_ERROR(TYPE_MISMATCH);
2163         case JVMTI_ERROR_INVALID_SLOT:
2164             return JDWP_ERROR(INVALID_SLOT);
2165         case JVMTI_ERROR_DUPLICATE:
2166             return JDWP_ERROR(DUPLICATE);
2167         case JVMTI_ERROR_NOT_FOUND:
2168             return JDWP_ERROR(NOT_FOUND);
2169         case JVMTI_ERROR_INVALID_MONITOR:
2170             return JDWP_ERROR(INVALID_MONITOR);
2171         case JVMTI_ERROR_NOT_MONITOR_OWNER:
2172             return JDWP_ERROR(NOT_MONITOR_OWNER);
2173         case JVMTI_ERROR_INTERRUPT:
2174             return JDWP_ERROR(INTERRUPT);
2175         case JVMTI_ERROR_INVALID_CLASS_FORMAT:
2176             return JDWP_ERROR(INVALID_CLASS_FORMAT);
2177         case JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION:
2178             return JDWP_ERROR(CIRCULAR_CLASS_DEFINITION);
2179         case JVMTI_ERROR_FAILS_VERIFICATION:
2180             return JDWP_ERROR(FAILS_VERIFICATION);
2181         case JVMTI_ERROR_INVALID_TYPESTATE:
2182             return JDWP_ERROR(INVALID_TYPESTATE);
2183         case JVMTI_ERROR_UNSUPPORTED_VERSION:
2184             return JDWP_ERROR(UNSUPPORTED_VERSION);
2185         case JVMTI_ERROR_NAMES_DONT_MATCH:
2186             return JDWP_ERROR(NAMES_DONT_MATCH);
2187         case AGENT_ERROR_NULL_POINTER:
2188         case JVMTI_ERROR_NULL_POINTER:
2189             return JDWP_ERROR(NULL_POINTER);
2190         case JVMTI_ERROR_ABSENT_INFORMATION:
2191             return JDWP_ERROR(ABSENT_INFORMATION);
2192         case AGENT_ERROR_INVALID_EVENT_TYPE:
2193         case JVMTI_ERROR_INVALID_EVENT_TYPE:
2194             return JDWP_ERROR(INVALID_EVENT_TYPE);
2195         case AGENT_ERROR_ILLEGAL_ARGUMENT:
2196         case JVMTI_ERROR_ILLEGAL_ARGUMENT:
2197             return JDWP_ERROR(ILLEGAL_ARGUMENT);
2198         case JVMTI_ERROR_OUT_OF_MEMORY:
2199         case AGENT_ERROR_OUT_OF_MEMORY:
2200             return JDWP_ERROR(OUT_OF_MEMORY);
2201         case JVMTI_ERROR_ACCESS_DENIED:
2202             return JDWP_ERROR(ACCESS_DENIED);
2203         case JVMTI_ERROR_WRONG_PHASE:
2204         case AGENT_ERROR_VM_DEAD:
2205         case AGENT_ERROR_NO_JNI_ENV:
2206             return JDWP_ERROR(VM_DEAD);
2207         case AGENT_ERROR_JNI_EXCEPTION:
2208         case JVMTI_ERROR_UNATTACHED_THREAD:
2209             return JDWP_ERROR(UNATTACHED_THREAD);
2210         case JVMTI_ERROR_NOT_AVAILABLE:
2211         case JVMTI_ERROR_MUST_POSSESS_CAPABILITY:
2212             return JDWP_ERROR(NOT_IMPLEMENTED);
2213         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED:
2214             return JDWP_ERROR(HIERARCHY_CHANGE_NOT_IMPLEMENTED);
2215         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED:
2216             return JDWP_ERROR(DELETE_METHOD_NOT_IMPLEMENTED);
2217         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED:
2218             return JDWP_ERROR(ADD_METHOD_NOT_IMPLEMENTED);
2219         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED:
2220             return JDWP_ERROR(SCHEMA_CHANGE_NOT_IMPLEMENTED);
2221         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED:
2222             return JDWP_ERROR(CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED);
2223         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED:
2224             return JDWP_ERROR(METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED);
2225         case JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED:
2226             return JDWP_ERROR(CLASS_ATTRIBUTE_CHANGE_NOT_IMPLEMENTED);
2227         case AGENT_ERROR_NOT_CURRENT_FRAME:
2228             return JDWP_ERROR(NOT_CURRENT_FRAME);
2229         case AGENT_ERROR_INVALID_TAG:
2230             return JDWP_ERROR(INVALID_TAG);
2231         case AGENT_ERROR_ALREADY_INVOKING:
2232             return JDWP_ERROR(ALREADY_INVOKING);
2233         case AGENT_ERROR_INVALID_INDEX:
2234             return JDWP_ERROR(INVALID_INDEX);
2235         case AGENT_ERROR_INVALID_LENGTH:
2236             return JDWP_ERROR(INVALID_LENGTH);
2237         case AGENT_ERROR_INVALID_STRING:
2238             return JDWP_ERROR(INVALID_STRING);
2239         case AGENT_ERROR_INVALID_CLASS_LOADER:
2240             return JDWP_ERROR(INVALID_CLASS_LOADER);
2241         case AGENT_ERROR_INVALID_ARRAY:
2242             return JDWP_ERROR(INVALID_ARRAY);
2243         case AGENT_ERROR_TRANSPORT_LOAD:
2244             return JDWP_ERROR(TRANSPORT_LOAD);
2245         case AGENT_ERROR_TRANSPORT_INIT:
2246             return JDWP_ERROR(TRANSPORT_INIT);
2247         case AGENT_ERROR_NATIVE_METHOD:
2248             return JDWP_ERROR(NATIVE_METHOD);
2249         case AGENT_ERROR_INVALID_COUNT:
2250             return JDWP_ERROR(INVALID_COUNT);
2251         case AGENT_ERROR_INVALID_FRAMEID:
2252             return JDWP_ERROR(INVALID_FRAMEID);
2253         case JVMTI_ERROR_INTERNAL:
2254         case JVMTI_ERROR_INVALID_ENVIRONMENT:
2255         case AGENT_ERROR_INTERNAL:
2256         case AGENT_ERROR_JVMTI_INTERNAL:
2257         case AGENT_ERROR_JDWP_INTERNAL:
2258             return JDWP_ERROR(INTERNAL);
2259         default:
2260             break;
2261     }
2262     return JDWP_ERROR(INTERNAL);
2263 }
2264 
2265 jint
2266 map2jdwpSuspendStatus(jint state)
2267 {
2268     jint status = 0;
2269     if ( ( state & JVMTI_THREAD_STATE_SUSPENDED ) != 0 )  {
2270         status = JDWP_SUSPEND_STATUS(SUSPENDED);
2271     }
2272     return status;
2273 }
2274 
2275 jdwpThreadStatus
2276 map2jdwpThreadStatus(jint state)
2277 {
2278     jdwpThreadStatus status;
2279 
2280     status = (jdwpThreadStatus)(-1);
2281 
2282     if ( ! ( state & JVMTI_THREAD_STATE_ALIVE ) ) {
2283         if ( state & JVMTI_THREAD_STATE_TERMINATED ) {
2284             status = JDWP_THREAD_STATUS(ZOMBIE);
2285         } else {
2286             /* FIXUP? New JDWP #define for not started? */
2287             status = (jdwpThreadStatus)(-1);
2288         }
2289     } else {
2290         if ( state & JVMTI_THREAD_STATE_SLEEPING ) {
2291             status = JDWP_THREAD_STATUS(SLEEPING);
2292         } else if ( state & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER ) {
2293             status = JDWP_THREAD_STATUS(MONITOR);
2294         } else if ( state & JVMTI_THREAD_STATE_WAITING ) {
2295             status = JDWP_THREAD_STATUS(WAIT);
2296         } else if ( state & JVMTI_THREAD_STATE_RUNNABLE ) {
2297             status = JDWP_THREAD_STATUS(RUNNING);
2298         }
2299     }
2300     return status;
2301 }
2302 
2303 jint
2304 map2jdwpClassStatus(jint classStatus)
2305 {
2306     jint status = 0;
2307     if ( ( classStatus & JVMTI_CLASS_STATUS_VERIFIED ) != 0 ) {
2308         status |= JDWP_CLASS_STATUS(VERIFIED);
2309     }
2310     if ( ( classStatus & JVMTI_CLASS_STATUS_PREPARED ) != 0 ) {
2311         status |= JDWP_CLASS_STATUS(PREPARED);
2312     }
2313     if ( ( classStatus & JVMTI_CLASS_STATUS_INITIALIZED ) != 0 ) {
2314         status |= JDWP_CLASS_STATUS(INITIALIZED);
2315     }
2316     if ( ( classStatus & JVMTI_CLASS_STATUS_ERROR ) != 0 ) {
2317         status |= JDWP_CLASS_STATUS(ERROR);
2318     }
2319     return status;
2320 }
2321 
2322 void
2323 log_debugee_location(const char *func,
2324         jthread thread, jmethodID method, jlocation location)
2325 {
2326     int logging_locations = LOG_TEST(JDWP_LOG_LOC);
2327 
2328     if ( logging_locations ) {
2329         char *method_name;
2330         char *class_sig;
2331         jvmtiError error;
2332         jvmtiThreadInfo info;
2333         jint state;
2334 
2335         /* Get thread information */
2336         info.name = NULL;
2337         error = FUNC_PTR(gdata->jvmti,GetThreadInfo)
2338                                 (gdata->jvmti, thread, &info);
2339         if ( error != JVMTI_ERROR_NONE) {
2340             info.name = NULL;
2341         }
2342         error = FUNC_PTR(gdata->jvmti,GetThreadState)
2343                                 (gdata->jvmti, thread, &state);
2344         if ( error != JVMTI_ERROR_NONE) {
2345             state = 0;
2346         }
2347 
2348         /* Get method if necessary */
2349         if ( method==NULL ) {
2350             error = FUNC_PTR(gdata->jvmti,GetFrameLocation)
2351                         (gdata->jvmti, thread, 0, &method, &location);
2352             if ( error != JVMTI_ERROR_NONE ) {
2353                 method = NULL;
2354                 location = 0;
2355             }
2356         }
2357 
2358         /* Get method name */
2359         method_name = NULL;
2360         if ( method != NULL ) {
2361             error = methodSignature(method, &method_name, NULL, NULL);
2362             if ( error != JVMTI_ERROR_NONE ) {
2363                 method_name = NULL;
2364             }
2365         }
2366 
2367         /* Get class signature */
2368         class_sig = NULL;
2369         if ( method != NULL ) {
2370             jclass clazz;
2371 
2372             error = methodClass(method, &clazz);
2373             if ( error == JVMTI_ERROR_NONE ) {
2374                 error = classSignature(clazz, &class_sig, NULL);
2375                 if ( error != JVMTI_ERROR_NONE ) {
2376                     class_sig = NULL;
2377                 }
2378             }
2379         }
2380 
2381         /* Issue log message */
2382         LOG_LOC(("%s: debugee: thread=%p(%s:0x%x),method=%p(%s@%d;%s)",
2383                 func,
2384                 thread, info.name==NULL ? "?" : info.name, state,
2385                 method, method_name==NULL ? "?" : method_name,
2386                 (int)location, class_sig==NULL ? "?" : class_sig));
2387 
2388         /* Free memory */
2389         if ( class_sig != NULL ) {
2390             jvmtiDeallocate(class_sig);
2391         }
2392         if ( method_name != NULL ) {
2393             jvmtiDeallocate(method_name);
2394         }
2395         if ( info.name != NULL ) {
2396             jvmtiDeallocate(info.name);
2397         }
2398     }
2399 }
2400 
2401 /* ********************************************************************* */
2402 /* JDK 6.0: Use of new Heap Iteration functions */
2403 /* ********************************************************************* */
2404 
2405 /* ********************************************************************* */
2406 /* Instances */
2407 
2408 /* Structure to hold class instances heap iteration data (arg user_data) */
2409 typedef struct ClassInstancesData {
2410     jint         instCount;
2411     jint         maxInstances;
2412     jlong        objTag;
2413     jvmtiError   error;
2414 } ClassInstancesData;
2415 
2416 /* Callback for instance object tagging (heap_reference_callback). */
2417 static jint JNICALL
2418 cbObjectTagInstance(jvmtiHeapReferenceKind reference_kind,
2419      const jvmtiHeapReferenceInfo* reference_info, jlong class_tag,
2420      jlong referrer_class_tag, jlong size,
2421      jlong* tag_ptr, jlong* referrer_tag_ptr, jint length, void* user_data)
2422 {
2423     ClassInstancesData  *data;
2424 
2425     /* Check data structure */
2426     data = (ClassInstancesData*)user_data;
2427     if (data == NULL) {
2428         return JVMTI_VISIT_ABORT;
2429     }
2430 
2431     /* If we have tagged enough objects, just abort */
2432     if ( data->maxInstances != 0 && data->instCount >= data->maxInstances ) {
2433         return JVMTI_VISIT_ABORT;
2434     }
2435 
2436     /* If tagged already, just continue */
2437     if ( (*tag_ptr) != (jlong)0 ) {
2438         return JVMTI_VISIT_OBJECTS;
2439     }
2440 
2441     /* Tag the object so we don't count it again, and so we can retrieve it */
2442     (*tag_ptr) = data->objTag;
2443     data->instCount++;
2444     return JVMTI_VISIT_OBJECTS;
2445 }
2446 
2447 /* Get instances for one class */
2448 jvmtiError
2449 classInstances(jclass klass, ObjectBatch *instances, int maxInstances)
2450 {
2451     ClassInstancesData data;
2452     jvmtiHeapCallbacks heap_callbacks;
2453     jvmtiError         error;
2454     jvmtiEnv          *jvmti;
2455 
2456     /* Check interface assumptions */
2457 
2458     if (klass == NULL) {
2459         return AGENT_ERROR_INVALID_OBJECT;
2460     }
2461 
2462     if ( maxInstances < 0 || instances == NULL) {
2463         return AGENT_ERROR_ILLEGAL_ARGUMENT;
2464     }
2465 
2466     /* Initialize return information */
2467     instances->count   = 0;
2468     instances->objects = NULL;
2469 
2470     /* Get jvmti environment to use */
2471     jvmti = getSpecialJvmti();
2472     if ( jvmti == NULL ) {
2473         return AGENT_ERROR_INTERNAL;
2474     }
2475 
2476     /* Setup data to passed around the callbacks */
2477     data.instCount    = 0;
2478     data.maxInstances = maxInstances;
2479     data.objTag       = (jlong)1;
2480     data.error        = JVMTI_ERROR_NONE;
2481 
2482     /* Clear out callbacks structure */
2483     (void)memset(&heap_callbacks,0,sizeof(heap_callbacks));
2484 
2485     /* Set the callbacks we want */
2486     heap_callbacks.heap_reference_callback = &cbObjectTagInstance;
2487 
2488     /* Follow references, no initiating object, just this class, all objects */
2489     error = JVMTI_FUNC_PTR(jvmti,FollowReferences)
2490                  (jvmti, 0, klass, NULL, &heap_callbacks, &data);
2491     if ( error == JVMTI_ERROR_NONE ) {
2492         error = data.error;
2493     }
2494 
2495     /* Get all the instances now that they are tagged */
2496     if ( error == JVMTI_ERROR_NONE ) {
2497         error = JVMTI_FUNC_PTR(jvmti,GetObjectsWithTags)
2498                       (jvmti, 1, &(data.objTag), &(instances->count),
2499                        &(instances->objects), NULL);
2500         /* Verify we got the count we expected */
2501         if ( data.instCount != instances->count ) {
2502             error = AGENT_ERROR_INTERNAL;
2503         }
2504     }
2505 
2506     /* Dispose of any special jvmti environment */
2507     (void)JVMTI_FUNC_PTR(jvmti,DisposeEnvironment)(jvmti);
2508     return error;
2509 }
2510 
2511 /* ********************************************************************* */
2512 /* Instance counts. */
2513 
2514 /* Macros to convert a class or instance tag to an index and back again */
2515 #define INDEX2CLASSTAG(i)      ((jlong)((i)+1))
2516 #define CLASSTAG2INDEX(t)      (((int)(t))-1)
2517 #define JLONG_ABS(x)           (((x)<(jlong)0)?-(x):(x))
2518 
2519 /* Structure to hold class count heap traversal data (arg user_data) */
2520 typedef struct ClassCountData {
2521     int          classCount;
2522     jlong       *counts;
2523     jlong        negObjTag;
2524     jvmtiError   error;
2525 } ClassCountData;
2526 
2527 /* Two different cbObjectCounter's, one for FollowReferences, one for
2528  *    IterateThroughHeap. Pick a card, any card.
2529  */
2530 
2531 /* Callback for object count heap traversal (heap_reference_callback) */
2532 static jint JNICALL
2533 cbObjectCounterFromRef(jvmtiHeapReferenceKind reference_kind,
2534      const jvmtiHeapReferenceInfo* reference_info, jlong class_tag,
2535      jlong referrer_class_tag, jlong size,
2536      jlong* tag_ptr, jlong* referrer_tag_ptr, jint length, void* user_data)
2537 {
2538     ClassCountData  *data;
2539     int              index;
2540     jlong            jindex;
2541     jlong            tag;
2542 
2543     /* Check data structure */
2544     data = (ClassCountData*)user_data;
2545     if (data == NULL) {
2546         return JVMTI_VISIT_ABORT;
2547     }
2548 
2549     /* Classes with no class_tag should have been filtered out. */
2550     if ( class_tag == (jlong)0 ) {
2551         data->error = AGENT_ERROR_INTERNAL;
2552         return JVMTI_VISIT_ABORT;
2553     }
2554 
2555     /* Class tag not one we really want (jclass not in supplied list) */
2556     if ( class_tag == data->negObjTag ) {
2557         return JVMTI_VISIT_OBJECTS;
2558     }
2559 
2560     /* If object tag is negative, just continue, we counted it */
2561     tag = (*tag_ptr);
2562     if ( tag < (jlong)0 ) {
2563         return JVMTI_VISIT_OBJECTS;
2564     }
2565 
2566     /* Tag the object with a negative value just so we don't count it again */
2567     if ( tag == (jlong)0 ) {
2568         /* This object had no tag value, so we give it the negObjTag value */
2569         (*tag_ptr) = data->negObjTag;
2570     } else {
2571         /* If this object had a positive tag value, it must be one of the
2572          *    jclass objects we tagged. We need to preserve the value of
2573          *    this tag for later objects that might have this as a class
2574          *    tag, so we just make the existing tag value negative.
2575          */
2576         (*tag_ptr) = -tag;
2577     }
2578 
2579     /* Absolute value of class tag is an index into the counts[] array */
2580     jindex = JLONG_ABS(class_tag);
2581     index = CLASSTAG2INDEX(jindex);
2582     if (index < 0 || index >= data->classCount) {
2583         data->error = AGENT_ERROR_ILLEGAL_ARGUMENT;
2584         return JVMTI_VISIT_ABORT;
2585     }
2586 
2587     /* Bump instance count on this class */
2588     data->counts[index]++;
2589     return JVMTI_VISIT_OBJECTS;
2590 }
2591 
2592 /* Callback for instance count heap traversal (heap_iteration_callback) */
2593 static jint JNICALL
2594 cbObjectCounter(jlong class_tag, jlong size, jlong* tag_ptr, jint length,
2595                         void* user_data)
2596 {
2597     ClassCountData  *data;
2598     int              index;
2599 
2600     /* Check data structure */
2601     data = (ClassCountData*)user_data;
2602     if (data == NULL) {
2603         return JVMTI_VISIT_ABORT;
2604     }
2605 
2606     /* Classes with no tag should be filtered out. */
2607     if ( class_tag == (jlong)0 ) {
2608         data->error = AGENT_ERROR_INTERNAL;
2609         return JVMTI_VISIT_ABORT;
2610     }
2611 
2612     /* Class tag is actually an index into data arrays */
2613     index = CLASSTAG2INDEX(class_tag);
2614     if (index < 0 || index >= data->classCount) {
2615         data->error = AGENT_ERROR_ILLEGAL_ARGUMENT;
2616         return JVMTI_VISIT_ABORT;
2617     }
2618 
2619     /* Bump instance count on this class */
2620     data->counts[index]++;
2621     return JVMTI_VISIT_OBJECTS;
2622 }
2623 
2624 /* Get instance counts for a set of classes */
2625 jvmtiError
2626 classInstanceCounts(jint classCount, jclass *classes, jlong *counts)
2627 {
2628     jvmtiHeapCallbacks heap_callbacks;
2629     ClassCountData     data;
2630     jvmtiError         error;
2631     jvmtiEnv          *jvmti;
2632     int                i;
2633 
2634     /* Check interface assumptions */
2635     if ( classes == NULL || classCount <= 0 || counts == NULL ) {
2636         return AGENT_ERROR_ILLEGAL_ARGUMENT;
2637     }
2638 
2639     /* Initialize return information */
2640     for ( i = 0 ; i < classCount ; i++ ) {
2641         counts[i] = (jlong)0;
2642     }
2643 
2644     /* Get jvmti environment to use */
2645     jvmti = getSpecialJvmti();
2646     if ( jvmti == NULL ) {
2647         return AGENT_ERROR_INTERNAL;
2648     }
2649 
2650     /* Setup class data structure */
2651     data.error        = JVMTI_ERROR_NONE;
2652     data.classCount   = classCount;
2653     data.counts       = counts;
2654 
2655     error = JVMTI_ERROR_NONE;
2656     /* Set tags on classes, use index in classes[] as the tag value. */
2657     error             = JVMTI_ERROR_NONE;
2658     for ( i = 0 ; i < classCount ; i++ ) {
2659         if (classes[i] != NULL) {
2660             jlong tag;
2661 
2662             tag = INDEX2CLASSTAG(i);
2663             error = JVMTI_FUNC_PTR(jvmti,SetTag) (jvmti, classes[i], tag);
2664             if ( error != JVMTI_ERROR_NONE ) {
2665                 break;
2666             }
2667         }
2668     }
2669 
2670     /* Traverse heap, two ways to do this for instance counts. */
2671     if ( error == JVMTI_ERROR_NONE ) {
2672 
2673         /* Clear out callbacks structure */
2674         (void)memset(&heap_callbacks,0,sizeof(heap_callbacks));
2675 
2676         /* Check debug flags to see how to do this. */
2677         if ( (gdata->debugflags & USE_ITERATE_THROUGH_HEAP) == 0 ) {
2678 
2679             /* Using FollowReferences only gives us live objects, but we
2680              *   need to tag the objects to avoid counting them twice since
2681              *   the callback is per reference.
2682              *   The jclass objects have been tagged with their index in the
2683              *   supplied list, and that tag may flip to negative if it
2684              *   is also an object of interest.
2685              *   All other objects being counted that weren't in the
2686              *   supplied classes list will have a negative classCount
2687              *   tag value. So all objects counted will have negative tags.
2688              *   If the absolute tag value is an index in the supplied
2689              *   list, then it's one of the supplied classes.
2690              */
2691             data.negObjTag = -INDEX2CLASSTAG(classCount);
2692 
2693             /* Setup callbacks, only using object reference callback */
2694             heap_callbacks.heap_reference_callback = &cbObjectCounterFromRef;
2695 
2696             /* Follow references, no initiating object, tagged classes only */
2697             error = JVMTI_FUNC_PTR(jvmti,FollowReferences)
2698                           (jvmti, JVMTI_HEAP_FILTER_CLASS_UNTAGGED,
2699                            NULL, NULL, &heap_callbacks, &data);
2700 
2701         } else {
2702 
2703             /* Using IterateThroughHeap means that we will visit each object
2704              *   once, so no special tag tricks here. Just simple counting.
2705              *   However in this case the object might not be live, so we do
2706              *   a GC beforehand to make sure we minimize this.
2707              */
2708 
2709             /* FIXUP: Need some kind of trigger here to avoid excessive GC's? */
2710             error = JVMTI_FUNC_PTR(jvmti,ForceGarbageCollection)(jvmti);
2711             if ( error != JVMTI_ERROR_NONE ) {
2712 
2713                 /* Setup callbacks, just need object callback */
2714                 heap_callbacks.heap_iteration_callback = &cbObjectCounter;
2715 
2716                 /* Iterate through entire heap, tagged classes only */
2717                 error = JVMTI_FUNC_PTR(jvmti,IterateThroughHeap)
2718                               (jvmti, JVMTI_HEAP_FILTER_CLASS_UNTAGGED,
2719                                NULL, &heap_callbacks, &data);
2720 
2721             }
2722         }
2723 
2724         /* Use data error if needed */
2725         if ( error == JVMTI_ERROR_NONE ) {
2726             error = data.error;
2727         }
2728 
2729     }
2730 
2731     /* Dispose of any special jvmti environment */
2732     (void)JVMTI_FUNC_PTR(jvmti,DisposeEnvironment)(jvmti);
2733     return error;
2734 }
2735 
2736 /* ********************************************************************* */
2737 /* Referrers */
2738 
2739 /* Structure to hold object referrer heap traversal data (arg user_data) */
2740 typedef struct ReferrerData {
2741   int        refCount;
2742   int        maxObjects;
2743   jlong      refTag;
2744   jlong      objTag;
2745   jboolean   selfRef;
2746   jvmtiError error;
2747 } ReferrerData;
2748 
2749 /* Callback for referrers object tagging (heap_reference_callback). */
2750 static jint JNICALL
2751 cbObjectTagReferrer(jvmtiHeapReferenceKind reference_kind,
2752      const jvmtiHeapReferenceInfo* reference_info, jlong class_tag,
2753      jlong referrer_class_tag, jlong size,
2754      jlong* tag_ptr, jlong* referrer_tag_ptr, jint length, void* user_data)
2755 {
2756     ReferrerData  *data;
2757 
2758     /* Check data structure */
2759     data = (ReferrerData*)user_data;
2760     if (data == NULL) {
2761         return JVMTI_VISIT_ABORT;
2762     }
2763 
2764     /* If we have tagged enough objects, just abort */
2765     if ( data->maxObjects != 0 && data->refCount >= data->maxObjects ) {
2766         return JVMTI_VISIT_ABORT;
2767     }
2768 
2769     /* If not of interest, just continue */
2770     if ( (*tag_ptr) != data->objTag ) {
2771         return JVMTI_VISIT_OBJECTS;
2772     }
2773 
2774     /* Self reference that we haven't counted? */
2775     if ( tag_ptr == referrer_tag_ptr ) {
2776         if ( data->selfRef == JNI_FALSE ) {
2777             data->selfRef = JNI_TRUE;
2778             data->refCount++;
2779         }
2780         return JVMTI_VISIT_OBJECTS;
2781     }
2782 
2783     /* If the referrer can be tagged, and hasn't been tagged, tag it */
2784     if ( referrer_tag_ptr != NULL ) {
2785         if ( (*referrer_tag_ptr) == (jlong)0 ) {
2786             *referrer_tag_ptr = data->refTag;
2787             data->refCount++;
2788         }
2789     }
2790     return JVMTI_VISIT_OBJECTS;
2791 }
2792 
2793 /* Heap traversal to find referrers of an object */
2794 jvmtiError
2795 objectReferrers(jobject obj, ObjectBatch *referrers, int maxObjects)
2796 {
2797     jvmtiHeapCallbacks heap_callbacks;
2798     ReferrerData       data;
2799     jvmtiError         error;
2800     jvmtiEnv          *jvmti;
2801 
2802     /* Check interface assumptions */
2803     if (obj == NULL) {
2804         return AGENT_ERROR_INVALID_OBJECT;
2805     }
2806     if (referrers == NULL || maxObjects < 0 ) {
2807         return AGENT_ERROR_ILLEGAL_ARGUMENT;
2808     }
2809 
2810     /* Initialize return information */
2811     referrers->count = 0;
2812     referrers->objects = NULL;
2813 
2814     /* Get jvmti environment to use */
2815     jvmti = getSpecialJvmti();
2816     if ( jvmti == NULL ) {
2817         return AGENT_ERROR_INTERNAL;
2818     }
2819 
2820     /* Fill in the data structure passed around the callbacks */
2821     data.refCount   = 0;
2822     data.maxObjects = maxObjects;
2823     data.objTag     = (jlong)1;
2824     data.refTag     = (jlong)2;
2825     data.selfRef    = JNI_FALSE;
2826     data.error      = JVMTI_ERROR_NONE;
2827 
2828     /* Tag the object of interest */
2829     error = JVMTI_FUNC_PTR(jvmti,SetTag) (jvmti, obj, data.objTag);
2830 
2831     /* No need to go any further if we can't tag the object */
2832     if ( error == JVMTI_ERROR_NONE ) {
2833 
2834         /* Clear out callbacks structure */
2835         (void)memset(&heap_callbacks,0,sizeof(heap_callbacks));
2836 
2837         /* Setup callbacks we want */
2838         heap_callbacks.heap_reference_callback = &cbObjectTagReferrer;
2839 
2840         /* Follow references, no initiating object, all classes, 1 tagged objs */
2841         error = JVMTI_FUNC_PTR(jvmti,FollowReferences)
2842                       (jvmti, JVMTI_HEAP_FILTER_UNTAGGED,
2843                        NULL, NULL, &heap_callbacks, &data);
2844 
2845         /* Use data error if needed */
2846         if ( error == JVMTI_ERROR_NONE ) {
2847             error = data.error;
2848         }
2849 
2850     }
2851 
2852     /* Watch out for self-reference */
2853     if ( error == JVMTI_ERROR_NONE && data.selfRef == JNI_TRUE ) {
2854         /* Tag itself as a referer */
2855         error = JVMTI_FUNC_PTR(jvmti,SetTag) (jvmti, obj, data.refTag);
2856     }
2857 
2858     /* Get the jobjects for the tagged referrer objects.  */
2859     if ( error == JVMTI_ERROR_NONE ) {
2860         error = JVMTI_FUNC_PTR(jvmti,GetObjectsWithTags)
2861                     (jvmti, 1, &(data.refTag), &(referrers->count),
2862                           &(referrers->objects), NULL);
2863         /* Verify we got the count we expected */
2864         if ( data.refCount != referrers->count ) {
2865             error = AGENT_ERROR_INTERNAL;
2866         }
2867     }
2868 
2869     /* Dispose of any special jvmti environment */
2870     (void)JVMTI_FUNC_PTR(jvmti,DisposeEnvironment)(jvmti);
2871     return error;
2872 }
--- EOF ---