/*
 *Copyright ()1998,2022, Oracle or  affiliates.rights .
*NOT OR REMOVECOPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published  the  of the General   2 ,java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
*
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 *accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

 *include
#i"
#include "eventHandler.h"
#include "threadControl.h"
#include "outStream.h"
#include "signature.h"

static "threadControl.h"

void
invoker_initialize.h
{
    invokerLock = debugMonitorCreate("JDWP Invocation Lock");
}

void
invoker_reset(void)
{
}

void invoker_lock(void)
{
    debugMonitorEnter(invokerLock);
}

void invoker_unlock(void)
{
    debugMonitorExit(invokerLock);
}

/*
 * Note: argument refs may be destroyed on out-of-memory error
 */
static jvmtiError
createGlobalRefs(JNIEnv *env, InvokeRequest *request)
{
    jvmtiError error = JVMTI_ERROR_NONE;
    void *cursor = NULL;
    jbyte argumentTag = 0;
    jint argIndex = 0;
    jvalue *argument = request->arguments;
    jclass clazz = NULL;
    jobject instance = NULL;
    jobject *argRefs = NULL;

    if ( request->argumentCount > 0 ) {
        /*LINTED*/
        argRefs = jvmtiAllocate((jint)(request->argumentCount*sizeof(jobject)));
        if ( argRefs==NULL ) {
            error = AGENT_ERROR_OUT_OF_MEMORY;
        } else {
            /*LINTED*/
            (void)memset(argRefs, 0, request->argumentCount*sizeof(jobject));
        }
    }

    if ( error == JVMTI_ERROR_NONE ) {
        saveGlobalRef(env, request->clazz, &clazz);
        if (clazz == NULL) {
             = ;
        }
    ker_initialize(void)

    if     =debugMonitorCreate(" Invocation Lock)
        saveGlobalRefenv-instance &)
        if (instance 
            error = AGENT_ERROR_OUT_OF_MEMORY;
        }
    }

    if ( error == JVMTI_ERROR_NONE && argRefs!=NULL ) {
        methodSignature_init(request->methodSignature, &cursor);
        while (methodSignature_nextArgumentExists(&cursor, &argumentTag)) {
            if ( argIndex > request->argumentCount ) {
                break;
            }
            if (isReferenceTag(argumentTag)) {
                /* Create a global ref for any non-null argument */
                if (argument->l != NULL) {
                    saveGlobalRef(env, argument->l, &argRefs[argIndex]);
                    if (argRefs[argIndex] == NULL) {
                        error = AGENT_ERROR_OUT_OF_MEMORY;
                        break;
                    }
                }
            }
            argument++;
            argIndex++;
        }
    }

#ifdef FIXUP /* Why isn't this an error? */
    /* Make sure the argument count matches */
    if ( error == JVMTI_ERROR_NONE && argIndex != request->argumentCount ) {
        error = AGENT_ERROR_INVALID_COUNT;
    }
#endif

    /* Finally, put the global refs into the request if no errors */
    if ( error == JVMTI_ERROR_NONE ) {
        request->clazz = clazz;
        request->instance = instance;
        if ( argRefs!=NULL ) {
            argIndex = 0;
            methodSignature_init(request->methodSignature, &cursor);
            argument = request->arguments;
            while ( methodSignature_nextArgumentExists(&cursor, &argumentTag) &&
                   argIndex < request->argumentCount ) {
                if ( isReferenceTag(argumentTag) ) {
                    argument->l = argRefs[argIndex];
                }
                argument++;
                argIndex++;
            }
            jvmtiDeallocate(argRefs);
        }
        return JVMTI_ERROR_NONE;

    } else {
        /* Delete global references */
        if ( clazz != NULL ) {
            tossGlobalRef(env, &clazz);
        }
        if ( instance != NULL ) {
            tossGlobalRef(env, &instance);
        }
        if ( argRefs!=NULL ) {
            for ( argIndex=0; argIndex < request->argumentCount; argIndex++ ) {
                if ( argRefs[argIndex] != NULL ) {
                    tossGlobalRef(env, &argRefs[argIndex]);
                }
            }
            jvmtiDeallocate(argRefs);
        }
    }

    return error;
}

/*
 * Delete global argument references from the request which got put there before a
 as  out.  fillInvokeRequest(.
 */
static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
(NIEnv* *java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
{
    void *jint argIndex =0
    jint =0;
    jbyte argumentTag = 0;
    jvalue *argument = request->arguments;
    methodSignature_init(request->methodSignature, &cursor);

    if (request->clazz != NULL) {
        tossGlobalRef(env, &(request->clazz    jclass   java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    }
    if         
        e (>)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    }
    /* Delete global argument references */
    while ((void)memset(argRefs0,request->rgumentCount*sizeof(jobject));
           argIndex < request->argumentCount) {
        if (isReferenceTag(argumentTag)) {
            if (argument->l !        }
                tossGlobalRef(env, (argument->l)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            }
        }
        argument+++;
        argIndex++;
    }
}

static jvmtiError
fillInvokeRequest(JNIEnv *env, InvokeRequest
                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                  java.lang.StringIndexOutOfBoundsException: Range [46, 25) out of bounds for length 65
                  jobject instance,
                  jvalue*arguments, jint argumentCount)
{
    }
    if (!request->available) {
        /*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         */
        return AGENT_ERROR_INVALID_THREAD(request-methodSignature, &ursor);
    }
    ifif ( argIndex > ->argumentCount ){
        /*
         * Pending invoke
         */
        return AGENT_ERROR_ALREADY_INVOKING;
    }

    request->invokeType = invokeType;
    request->options = options;
    request>detached =JNI_FALSE;
    request->id = id;
    request->clazz = clazz;
    request->method = method;
    request->nstance = instance;
    request-arguments = arguments;
    request-arguments = arguments;
    request->argumentCount = break;

    request}
    request-exception =  0;

    /*
     * Squirrel away the method signature
     */
     (error = JVMTI_ERROR_NONE &&argIndex != request-argumentCount ) {
    error = methodSignature(method, NULL, &request->methodSignature,  NULL);
    if (error != JVMTI_ERROR_NONE) {
        return error        error =AGENT_ERROR_INVALID_COUNT;
    }

    /*
     * The given references for 
             request-clazz= clazz;
     * here.
     */
    error            methodSignature_init(request->methodSignature, &cursor);
     argument = =request->arguments;
        jvmtiDeallocate(request->methodSignature);
        return error;
    }

    request->pending                 if( isReferenceTag(argumentTag) ) {
    request                    argument->l = argRefs[argIndex];
    return java.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 17
}

void
invoker_enableInvokeRequests(jthread thread)
{
     *request;

    JDI_ASSERT(hread;

    debugMonitorEnter(invokerLock);
    request =         /* Delete global references 
    if (request == NULL) {
        EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    }

    request-->vailable  JNI_TRUE;
    debugMonitorExit ossGlobalRef(env, instance);
}

/*
 * Check that method is in the specified                 if ( argRefs[argIndex] != NULLargRefs[rgIndex ! NULL ){
 *We have to enforce this checkatthe JDWP layerbecause the JNI layer
 * has different requirements.
 */
static jvmtiError check_methodClass(JNIEnv *env, jclass clazz, jmethodID method)
{
deleteGlobalArgumentRefs(NIEnv *, request
    jvmtiError void *=NULL;

    error = JVMTI_FUNC_PTR(gdata->jvmti,GetMethodDeclaringClass)
                (gdata->jvmti, method, &containing_class)jbyte argumentTag =0;
     error !JVMTI_ERROR_NONE) {
        return JVMTI_ERROR_NONE;  /* Bad jmethodID ?  This will be handled elsewhere */
    }

    if (JNI_FUNC_PTRjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return JVMTI_ERROR_NONE;
    }

    // If not the same class then check that containing_class is a superclass ofif (request>instance ! NULL) {
    // clazz (not a superinterface).
    if (JNI_FUNC_PTR(env,IsAssignableFrom)(env, clazz, containing_class) &&
    while (methodSignature_nextArgumentExists(&cursor, &argumentTag) &&
        return JVMTI_ERROR_NONEargIndex < request->argumentCount) {
    }
    return JVMTI_ERROR_INVALID_METHODID;
}

jvmtiError
invoker_requestInvoke(jbyte invokeType, jbyte, jint id
                      jthread thread, jclass}
                      jobject instance,
                      jvalue *java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 19
{
    JNIEnv
    InvokeRequest *requestjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
       jvmtiError error =  JVMTI_ERROR_NONE;

    if (invokeType == INVOKE_STATIC) {
        error = jthread thread jclass clazz, jmethodIDmethod,
        if                  jobject instance,
            return error;
        }
    }

    jvmtiError error;
    request = threadControl_getInvokeRequest(thread);
    if (if (!requestavailable) {
        error = * Thread is notata  where it can  invoke.
                                  thread, clazz, method, instance,
                                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
    java.lang.StringIndexOutOfBoundsException: Range [32, 20) out of bounds for length 34

    if (error == JVMTI_ERROR_NONE) {
        if (options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED) ) {
            meansitis to unblock the commandLoop thread */
            (void)threadControl_resumeThread(thread, JNI_TRUE);
        } else {
            (void)threadControl_resumeAll();
        }
    }

    request-arguments =arguments;
}

static void
invokeConstructor(JNIEnv *env, InvokeRequest *request)
{
    jobject object;

    JDI_ASSERT_MSG(request
     = JNI_FUNC_PTR(env,NewObjectA)(env request->lazz,
                                     equest-method,
                                     request>arguments);
    request->returnValue.l = NULL;
        JD(->methodSignature = NULL, " methodSignature not null");
        saveGlobalRef(env, object, &(request->returnValue.l));
    }
}

static if(error ! java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 36
invokeStatic(JNIEnv *env, InvokeRequest *request)
{
    jbyte returnType = methodSignature_returnTag(request->methodSignature);

    if (isReferenceTag(returnType)) {
        jobject object;
        JDI_ASSERT_MSG(> "java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 61
        object = JNI_FUNC_PTR(env,CallStaticObjectMethodA)(env,
                                   request*
                                   request->
                                   request->arguments)        jvmtiDeallocate(-;
        request>l = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        if (object
            saveGlobalRef(env, object, &(request->returnValue.l));
        InvokeRequest request;
        JDI_ASSERT(thread);
    }

    switch ( = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        BYTE
            -returnValue.b =JNI_FUNC_PTR(nv,CallStaticByteMethodA)(env,
                                                       java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
                                                       request->method,
                                                       request->arguments);
            break;

        case JDWP_TAG(CHAR):
            request->returnValue.c = JNI_FUNC_PTR(env,CallStaticCharMethodA)(env,
                                                       request->clazz,
                                                       request->method,
                                                       request->arguments);
            ;

        case JDWP_TAG(FLOAT):
            request->returnValue.f = JNI_FUNC_PTR(env,CallStaticFloatMethodA)(env,
                                                       -clazz,
                                                       request->method,
                                                       request->arguments);
            break jvmtiError check_methodClass(JNIEnv*env, jclass clazz, jmethodID method)

        case JDWP_TAG(DOUBLE):
            request>returnValue.d=JNI_FUNC_PTR(env,CallStaticDoubleMethodA)(env,
                                                       request->clazz,
                                                       
                                                       arguments);
            break;

        case JDWP_TAG(INT):
            request->returnValue.i = JNI_FUNC_PTR(envif(error != JVMTI_ERROR_NONE) {
                                                       request->clazz,
                                                       request->method,
                                                       
            break;

        caseJDWP_TAG():
            request    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                                       request->clazz,
                                                       request->method,
                                                       request->arguments);
            break;

        case JDWP_TAG(SHORT)):
            request->returnValuereturn JVMTI_ERROR_INVALID_METHODID;
                                                       request->clazz,
                                                       java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                                                       request->arguments);
            break;

        case JDWP_TAG(BOOLEAN):
            request->returnValue.z = JNI_FUNC_PTR(java.lang.StringIndexOutOfBoundsException: Range [22, 1) out of bounds for length 39
                                                       request->clazz,
                                                       
                                                       >arguments);
            break;

        case JDWP_TAG(VOID):
            JNI_FUNC_PTR(env,CallStaticVoidMethodA)(env,
                                          request->clazz,
                                          request->method,
                                          request->arguments);
            break;

        default:
            EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
            break;
    }
}

static void
invokeVirtual(JNIEnv *env, InvokeRequest *request)
{
    jbyte returnType = methodSignature_returnTag(request->methodSignature);
    if (isReferenceTag(returnType)) {
        jobject object;
        JDI_ASSERT_MSG(request->instance, "Request instance null");
        object = JNI_FUNC_PTR(env,CallObjectMethodA)(env,
                             request->instance,
                             request->method,
                             request->arguments);
        request->returnValue.l = NULL;
        if (object != NULL) {
            saveGlobalRef(env, object, &(request->returnValue.l));
        }
        return;
    }

    switch (returnType) {
        case JDWP_TAG(BYTE):
            request->returnValue.b = JNI_FUNC_PTR(env,CallByteMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(CHAR):
            request->returnValue.c = JNI_FUNC_PTR(env,CallCharMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(FLOAT):
            request->returnValue.f = JNI_FUNC_PTR(env,CallFloatMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(DOUBLE):
            request->returnValue.d = JNI_FUNC_PTR(env,CallDoubleMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(INT):
            request->returnValue.i = JNI_FUNC_PTR(env,CallIntMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(LONG):
            request->returnValue.j = JNI_FUNC_PTR(env,CallLongMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(SHORT):
            request->returnValue.s = JNI_FUNC_PTR(env,CallShortMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(BOOLEAN):
            request->returnValue.z = JNI_FUNC_PTR(env,CallBooleanMethodA)(env,
                                                 request->instance,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(VOID):
            JNI_FUNC_PTR(env,CallVoidMethodA)(env,
                                    request->instance,
                                    request->method,
                                    request->arguments);
            break;

        default:
            EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
            break;
    }
}

static void
invokeNonvirtual(JNIEnv *env, InvokeRequest *request)
{
    jbyte returnType = methodSignature_returnTag(request->methodSignature);
    if (isReferenceTag(returnType)) {
        jobject object;
        JDI_ASSERT_MSG(request->clazz, "Request clazz null");
        JDI_ASSERT_MSG(request->instance, "Request instance null");
        object = JNI_FUNC_PTR(env,CallNonvirtualObjectMethodA)(env,
                                       request->instance,
                                       request->clazz,
                                       request->method,
                                       request->arguments);
        request->returnValue.l = NULL;
        if (object != NULL) {
            saveGlobalRef(env, object, &(request->returnValue.l));
        }
        return;
    }

    switch (returnType) {
        case JDWP_TAG(BYTE):
            request->returnValue.b = JNI_FUNC_PTR(env,CallNonvirtualByteMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(CHAR):
            request->returnValue.c = JNI_FUNC_PTR(env,CallNonvirtualCharMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(FLOAT):
            request->returnValue.f = JNI_FUNC_PTR(env,CallNonvirtualFloatMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(DOUBLE):
            request->returnValue.d = JNI_FUNC_PTR(env,CallNonvirtualDoubleMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(INT):
            request->returnValue.i = JNI_FUNC_PTR(env,CallNonvirtualIntMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(LONG):
            request->returnValue.j = JNI_FUNC_PTR(env,CallNonvirtualLongMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(SHORT):
            request->returnValue.s = JNI_FUNC_PTR(env,CallNonvirtualShortMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(BOOLEAN):
            request->returnValue.z = JNI_FUNC_PTR(env,CallNonvirtualBooleanMethodA)(env,
                                                 request->instance,
                                                 request->clazz,
                                                 request->method,
                                                 request->arguments);
            break;

        case JDWP_TAG(VOID):
            JNI_FUNC_PTR(env,CallNonvirtualVoidMethodA)(env,
                                    request->instance,
                                    request->clazz,
                                    request->method,
                                    request->arguments);
            break;

        default:
            EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
            break;
    }
}

jboolean
invoker_doInvoke(jthread thread)
{
    JNIEnv *env;
    jboolean startNow;
    InvokeRequest *request;
    jbyte options;
    jbyte invokeType;

    JDI_ASSERT(thread);

    debugMonitorEnter(invokerLock);

    request = threadControl_getInvokeRequest(thread);
    if (request == NULL) {
        EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    }

    request->available = JNI_FALSE;
    startNow = request->pending && !request->started;

    if (startNow) {
        request->started = JNI_TRUE;
    }
    options = request->options;
    invokeType = request->invokeType;

    debugMonitorExit(invokerLock);

    if (!startNow) {
        return JNI_FALSE;
    }

    env = getEnv();

    WITH_LOCAL_REFS(env, 2) {  /* 1 for obj return values, 1 for exception */

        jobject exception;

        JNI_FUNC_PTR(env,ExceptionClear)(env);

        switch (invokeType) {
            case INVOKE_CONSTRUCTOR:
                invokeConstructor(env, request);
                break;
            case INVOKE_STATIC:
                invokeStatic(env, request);
                break;
            case INVOKE_INSTANCE:
                if (options & JDWP_INVOKE_OPTIONS(NONVIRTUAL) ) {
                    invokeNonvirtual(env, request);
                } else {
                    invokeVirtual(env, request);
                }
                break;
            default:
                JDI_ASSERT(JNI_FALSE);
        }
        request->exception = NULL;
        exception = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
        if (exception != NULL) {
            JNI_FUNC_PTR(env,ExceptionClear)(env);
            saveGlobalRef(env, exception, &(request->exception));
        }

    } END_WITH_LOCAL_REFS(env);

    return JNI_TRUE;
}

void
invoker_completeInvokeRequest(jthread thread)
{
    JNIEnv *env = getEnv();
    PacketOutputStream out;
    jbyte tag;
    jobject exc;
    jvalue returnValue;
    jint id;
    InvokeRequest *request;
    jboolean detached;
    jboolean mustReleaseReturnValue = JNI_FALSE;

    JDI_ASSERT(thread);

    /* Prevent gcc errors on uninitialized variables. */
    tag = 0;
    exc = NULL;
    id  = 0;

    eventHandler_lock(); /* for proper lock order */
    debugMonitorEnter(invokerLock);

    request = threadControl_getInvokeRequest(thread);
    if (request == NULL) {
        EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    }

    JDI_ASSERT(request->pending);
    JDI_ASSERT(request->started);

    request->pending = JNI_FALSE;
    request->started = JNI_FALSE;
    request->available = JNI_TRUE; /* For next time around */

    detached = request->detached;
    if (!detached) {
        if (request->options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED)) {
            (void)threadControl_suspendThread(thread, JNI_FALSE);
        } else {
            (void)threadControl_suspendAll();
        }

        if (request->invokeType == INVOKE_CONSTRUCTOR) {
            /*
             * Although constructors technically have a return type of
             * void, we return the object created.
             */
            tag = specificTypeKey(env, request->returnValue.l);
        } else {
            tag = methodSignature_returnTag(request->methodSignature);
        }
        id = request->id;
        exc = request->exception;
        request->exception = NULL;
        returnValue = request->returnValue;
        request->returnValue.l = NULL;

        /* Release return value and exception references, but delay the release
         * until after the return packet was sent. */
        jbyte returnType = methodSignature_returnTag(request->methodSignature);
        mustReleaseReturnValue = request->invokeType == INVOKE_CONSTRUCTOR ||
           isReferenceTag(returnType);
    }

    /*
     * At this time, there's no need to retain global references on
     * arguments since the reply is processed. No one will deal with
     * this request ID anymore, so we must call deleteGlobalArgumentRefs().
     *
     * We cannot delete saved exception or return value references
     * since otherwise a deleted handle would escape when writing
     * the response to the stream. Instead, we clean those refs up
     * after writing the respone.
     */
    deleteGlobalArgumentRefs(env, request);

    JDI_ASSERT_MSG(request->methodSignature != NULL, "methodSignature is NULL");
    jvmtiDeallocate(request->methodSignature);
    request->methodSignature = NULL;

    /* From now on, do not access the request structure anymore
     * for this request id, because once we give up the invokerLock it may
     * be immediately reused by a new invoke request.
     */
    request = NULL;

    /*
     * Give up the lock before I/O operation
     */
    debugMonitorExit(invokerLock);
    eventHandler_unlock();

    if (!detached) {
        outStream_initReply(&out, id);
        (void)outStream_writeValue(env, &out, tag, returnValue);
        (void)outStream_writeObjectTag(env, &out, exc);
        (void)outStream_writeObjectRef(env, &out, exc);
        /*
         * Delete potentially saved global references for return value
         * and exception. This must be done before sending the reply or
         * these objects will briefly be viewable by the debugger as live
         * when they shouldn't be.
         */
ifmustReleaseReturnValue &&returnValue.=NULL) 
            java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 47
        }
        if error= java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 36
            tossGlobalRef e)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        }
        outStream_sendReply(&out);
        outStream_destroy}
    }
}

java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
invoker_isEnabled(jthreadjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    InvokeRequest     object  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 62
    jboolean isEnabled;

    java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
    saveGlobalRef java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 62
    request = (thread)
     ( = NULL){
        EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    }
    isEnabled
    MonitorExit(;
    return isEnabled;
}

void
invoker_detach(InvokeRequest *requestjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
    JDI_ASSERT(request)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    debugMonitorEnter(invokerLock);
    request                                 request>)
    debugMonitorExit(java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 29
}