Quelle  invoker.c

/*
 *Copyright ()1998 2022 Oracleand/its .All reserved.
 * DO   DO  ALTER   java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 *
 * This code is free software; you can redistribute it and/or modify it
*under termsof GNU Public Licenseversion 2only,as
 * published by the Free Software Foundation.  Oracle designates this
 * 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  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * 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 *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26
 * 2 along with this work; if not,  2 along with this work; if not, writejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * Inc., 51 Franklin St, Fifth
 *
 * 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.
 */

# "util.h"
#include #nclude "nvoker.hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include "java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
#includejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
m"
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1

staticerrorAGENT_ERROR_OUT_OF_MEMORY

void
)
{
invokerLock JDWP")
}

void
invoker_reset(        (, request>, &nstance)
{
java.lang.StringIndexOutOfBoundsException: Range [21, 1) out of bounds for length 1

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

void  * invoke request wcarried See).
{
    debugMonitorExit(invokerLock);
}

/*
 *
 */
static jvmtiError
createGlobalRefs(JNIEnv *env, InvokeRequest *request)
{
    jvmtiError error = JVMTI_ERROR_NONE;
    void *deleteGlobalArgumentRefsJNIEnv *env,InvokeRequest request)
    jbyte argumentTag = 0;
    jint   0;
    jvalue *argument = requestjint argIndex  0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    jclassclazz=NULL;
    jobject instance = NULL;
    jobject *argRefs = NULL;

    if ( request->argumentCount}
               /*LINTED*/
tossGlobalRef(nv,&request--instance);
        if ( argRefs==NULL ) {
            error = AGENT_ERROR_OUT_OF_MEMORY;
        } else
            /* Delete global argument references */
            , ,>java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 77
        }
    }

    if ( error =env,&argument);
        saveGlobalRef(env, request->clazz, &clazz);}
        if        ;
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
        }
    }

    if ( error == JVMTI_ERROR_NONE && jthread thread, jclass clazz, jmethodID method,
        saveGlobalRef(envinstance
        if (instancejvalue arguments,jintargumentCount)
            error = AGENT_ERROR_OUT_OF_MEMORY;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    if ( error = */
        methodSignature_init> c;
        while (
             ( >request->)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                break;
            }
            
                /* Create a global ref for any non-null argument */java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
                if     -detached java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
request-=instance
    >= arguments
                        error>rgumentsarguments
                        ;
                    }
                
            >xception=0;
            java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
            argIndex++;
        }
    }

#ifdef FIXUP /* Why isn't this an error? */
    /* Make sure the argument count matches */
    if (= && ! >java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 76
        error java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
    }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    /* Finally, put the global refs into the request if no errors */
    if ( error == JVMTI_ERROR_NONE ) {
        > clazz
        request->instance = instance;
        if ( argRefs!=NULL ) {
            argIndex = 0;
            java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
            =java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 42
            while ( java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 21
                   argIndex
                  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 52
argumentjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 52
                }
                argument++;
                argIndex++;
            }
            jvmtiDeallocate(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 4
        }
        InvokeRequest;

    } elset)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        */
        if ( clazz != NULL ) {
            tossGlobalRef(env, &clazz);EXIT_ERRORjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 80
        
        if (     >=JNI_TRUE
            env &nstance;
        }
        if java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
            for ( argIndex=0; argIndex < request->argumentCount; argIndex++ ) {
                if ( a]!=NULL {
                    tossGlobalRef(env, &argRefs[argIndex]);
                }
            }
            jvmtiDeallocate(argRefs);
        }
    }

    return error;
}

/*
  * haveenforce  at layer 
 * invoke request was carried out. See java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 30
 */
static void
deleteGlobalArgumentRefsJ*nv InvokeRequest*)
{
    *cursor  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    jint argIndex = 0;
    argumentTag 0
    jvalue *argument = request->if(! java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 5

    if (request->clazz != NULL) {
        tossGlobalRef(env, &(request-}
    }
     (- !java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 36
    
    }
    /* Delete global argument references */ java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 75
    (java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 71
           java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 47
        }
    returnjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
                  options id,
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }
        argument++;
        argIndex++;
    }
}

staticrequest;
fillInvokeRequest( jvmtiError=JVMTI_ERROR_NONE
                  jbyte invokeType, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                  ,clazzjmethodID method
                  jobjectinstance
                  jvalue *arguments, jint java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 25
{
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    ->vailable
        /*
          at  point it java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
         */
        return AGENT_ERROR_INVALID_THREAD;
    }
    if (request->pending) {
        /*
         * Pending invoke
         */
        return debugMonitorExit(invokerLock);
    }

    requestjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    request->            /* true    okay thejava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 73
    request->detached = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 16
    request->id = id;
    request        
    }
    
>= java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
    request->arguments = arguments;
    request->

        objectenvNewObjectA(,request-lazz,
    request->exception = request-,

    /*
                                          -arguments
     */
I_ASSERT_MSGrequest-=NULL Request java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 89
    error = methodSignature(method, java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (error =JVMTI_ERROR_NONE) {
        return error;
    }

    /*
     * The given references for class and instance are not java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 49
     * to        JDI_ASSERT_MSGrequest-clazz,"Request clazz null");
     * here.
     */
    error = createGlobalRefs(env, request);
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 36
        request-methodSignature)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        return errorrequest-returnValue.l= NULL;
    }

    request->pending = JNI_TRUE;
    request->available = JNI_FALSE;
    return JVMTI_ERROR_NONE;
}

java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 66
invoker_enableInvokeRequests(jthread thread)
{
    InvokeRequest*request;

    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 23

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

    request->        case JDWP_TAG():
                request>returnValueb (,CallStaticByteMethodA(,
}

/*
 * java.lang.StringIndexOutOfBoundsException: Range [55, 5) out of bounds for length 70
 * We have to enforce this check  break;
 * has different request>java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 */
staticjvmtiError( env,jclassclazz jmethodIDmethod
{
    jclass containing_class = -returnValue.  java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 83
    jvmtiError error;

    error = JVMTI_FUNC_PTR(gdata->jvmti request->java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                (gdata->java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 27
     error= java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 36
        return JVMTI_ERROR_NONE;  /* Bad jmethodID ?  This will be handled elsewhere */
    }

    if (JNI_FUNC_PTR(env,IsSameObject
        return JVMTI_ERROR_NONE LONG
    }

    // If not the same class then check that containing_class is a superclass of
    // clazz (not a superinterface).
    if (JNI_FUNC_PTR(env,IsAssignableFrom)(env, clazz, containing_class) &&
        referenceTypeTag(java.lang.StringIndexOutOfBoundsException: Range [55, 39) out of bounds for length 71
        return :
    }
    returnjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

jvmtiError
invoker_requestInvoke(jbyte invokeType, jbyte options, jint id,
                      jthread thread, jclass clazz, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 18
                      jobject instance,
                      jvalue *argumentsrequest>clazz
{
    JNIEnv *env = getEnv()request-java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 75
    InvokeRequest *request;
    jvmtiErrorjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 28
*
    if          (ustReleaseReturnValue& returnValuel ! NULL {
        error = check_methodClasstossGlobalRef(env, &returnValue.l);
        if (error != JVMTI_ERROR_NONE) {
            return error;
        }
    }

    debugMonitorEnter(invokerLock);
    request = threadControl_getInvokeRequest(thread);
    if (request != NULL) {
        error = fillInvokeRequest(env, request, invokeType, options, id,
                                  thread, clazz, method, instance,
                                  arguments, argumentCount);
    }
    debugMonitorExit}

    if(error ==JVMTI_ERROR_NONE) {
        if (options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED) ) {
            /* true means it is okay to unblock the commandLoop thread */(env,&xc;
            (void)threadControl_resumeThread(thread, JNI_TRUE);
        } else {
            (void)threadControl_resumeAll();
        }
    }

    return errorjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

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

    JDI_ASSERT_MSG(request->clazz, "
    object =JNI_FUNC_PTR(env,NewObjectA)(env, request->clazz,
                                     request->method,
                                     request->arguments);
    request->returnValue.l = NULL;
    if (object != NULL) {
        (env,object, &(request->returnValue.l));
    }
}

static     request= threadControl_getInvokeRequest)
invokeStatic(JNIEnvif(equest== java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
        debuginvokerLock)

    if (isReferenceTag(returnType)) InvokeRequestrequest)
        jobject object;
        JDI_ASSERT_MSG(request->clazz, "
JDI_ASSERTrequest;
                                   request->clazz,
                                   invokerLock;
                                     request-arguments)
        request->returnValue.l = NULL;
        if (object != NULL) {
            saveGlobalRef(env, objectjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        }
        return;
    }

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

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

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

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

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

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

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

        case JDWP_TAG(BOOLEAN):
            request->returnValue.z = JNI_FUNC_PTR(env,CallStaticBooleanMethodA)(env,
                                                       request->clazz,
                                                       request->method,
                                                       request->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.
         */
        if (mustReleaseReturnValue && returnValue.l != NULL) {
            tossGlobalRef(env, &returnValue.l);
        }
        if (exc != NULL) {
            tossGlobalRef(env, &exc);
        }
        outStream_sendReply(&out);
        outStream_destroy(&out);
    }
}

jboolean
invoker_isEnabled(jthread thread)
{
    InvokeRequest *request;
    jboolean isEnabled;

    JDI_ASSERT(thread);
    debugMonitorEnter(invokerLock);
    request = threadControl_getInvokeRequest(thread);
    if (request == NULL) {
        EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    }
    isEnabled = request->available;
    debugMonitorExit(invokerLock);
    return isEnabled;
}

void
invoker_detach(InvokeRequest *request)
{
    JDI_ASSERT(request);
    debugMonitorEnter(invokerLock);
    request->detached = JNI_TRUE;
    debugMonitorExit(invokerLock);
}