/*
* Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT 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 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 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
* 2 along with this work; if not, write 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 "util.h"
#include "stepControl.h"
#include "eventHandler.h"
#include "eventHelper.h"
#include "threadControl.h"
#include "SDE.h"
static jrawMonitorID stepLock;
static jint
getFrameCount(jthread thread)
{
jint count = 0;
jvmtiError error;
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameCount)
(gdata->jvmti, thread, &count);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "getting frame count");
}
return count;
}
/*
* Most enabling/disabling of JVMTI events happens implicitly through
* the inserting and freeing of handlers for those events. Stepping is
* different because requested steps are usually not identical to JVMTI steps.
* They usually require multiple events step, and otherwise, before they
* complete. While a step request is pending, we may need to temporarily
* disable and re-enable stepping, but we can't just remove the handlers
* because that would break the application's ability to remove the
* events. So, for step events only, we directly enable and disable stepping.
* This is safe because there can only ever be one pending step request
* per thread.
*/
static void
enableStepping(jthread thread)
{
jvmtiError error;
LOG_STEP(("enableStepping: thread=%p", thread));
error = threadControl_setEventMode(JVMTI_ENABLE, EI_SINGLE_STEP,
thread);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "enabling single step");
}
}
static void
disableStepping(jthread thread)
{
jvmtiError error;
LOG_STEP(("disableStepping: thread=%p", thread));
error = threadControl_setEventMode(JVMTI_DISABLE, EI_SINGLE_STEP,
thread);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "disabling single step");
}
}
static jvmtiError
getFrameLocation(jthread thread,
jclass *pclazz, jmethodID *pmethod, jlocation *plocation)
{
jvmtiError error;
*pclazz = NULL;
*pmethod = NULL;
*plocation = -1;
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameLocation)
(gdata->jvmti, thread, 0, pmethod, plocation);
if (error == JVMTI_ERROR_NONE && *pmethod!=NULL ) {
/* This also serves to verify that the methodID is valid */
error = methodClass(*pmethod, pclazz);
}
return error;
}
static void
getLineNumberTable(jmethodID method, jint *pcount,
jvmtiLineNumberEntry **ptable)
{
jvmtiError error;
*pcount = 0;
*ptable = NULL;
/* If the method is native or obsolete, don't even ask for the line table */
if ( isMethodObsolete(method) || isMethodNative(method)) {
return;
}
error = JVMTI_FUNC_PTR(gdata->jvmti,GetLineNumberTable)
(gdata->jvmti, method, pcount, ptable);
if (error != JVMTI_ERROR_NONE) {
*pcount = 0;
}
}
static jint
findLineNumber(jthread thread, jlocation location,
jvmtiLineNumberEntry *lines, jint count)
{
jint line = -1;
if (location != -1) {
if (count > 0) {
jint i;
/* any preface before first line is assigned to first line */
for (i=1; i<count; i++) {
if (location < lines[i].start_location) {
break;
}
}
line = lines[i-1].line_number;
}
}
return line;
}
static jboolean
hasLineNumbers(jmethodID method)
{
jint count;
jvmtiLineNumberEntry *table;
getLineNumberTable(method, &count, &table);
if ( count == 0 ) {
return JNI_FALSE;
} else {
jvmtiDeallocate(table);
}
return JNI_TRUE;
}
static jvmtiError
initState(JNIEnv *env, jthread thread, StepRequest *step)
{
jvmtiError error;
/*
* Initial values that may be changed below
*/
step->fromLine = -1;
step->fromNative = JNI_FALSE;
step->frameExited = JNI_FALSE;
step->fromStackDepth = getFrameCount(thread);
if (step->fromStackDepth <= 0) {
/*
* If there are no stack frames, treat the step as though
* from a native frame. This is most likely to occur at the
* beginning of a debug session, right after the VM_INIT event,
* so we need to do something intelligent.
*/
step->fromNative = JNI_TRUE;
return JVMTI_ERROR_NONE;
}
/*
* Try to get a notification on frame pop. If we're in an opaque frame
* we won't be able to, but we can use other methods to detect that
* a native frame has exited.
*
* TO DO: explain the need for this notification.
*/
error = JVMTI_FUNC_PTR(gdata->jvmti,NotifyFramePop)
(gdata->jvmti, thread, 0);
if (error == JVMTI_ERROR_OPAQUE_FRAME) {
step->fromNative = JNI_TRUE;
error = JVMTI_ERROR_NONE;
/* continue without error */
} else if (error == JVMTI_ERROR_DUPLICATE) {
error = JVMTI_ERROR_NONE;
/* Already being notified, continue without error */
} else if (error != JVMTI_ERROR_NONE) {
return error;
}
LOG_STEP(("initState(): frame=%d", step->fromStackDepth));
/*
* Note: we can't undo the frame pop notify, so
* we'll just have to let the handler ignore it if
* there are any errors below.
*/
if (step->granularity == JDWP_STEP_SIZE(LINE) ) {
LOG_STEP(("initState(): Begin line step"));
WITH_LOCAL_REFS(env, 1) {
jclass clazz;
jmethodID method;
jlocation location;
error = getFrameLocation(thread, &clazz, &method, &location);
if (error == JVMTI_ERROR_NONE) {
/* Clear out previous line table only if we changed methods */
if ( method != step->method ) {
step->lineEntryCount = 0;
if (step->lineEntries != NULL) {
jvmtiDeallocate(step->lineEntries);
step->lineEntries = NULL;
}
step->method = method;
getLineNumberTable(step->method,
&step->lineEntryCount, &step->lineEntries);
if (step->lineEntryCount > 0) {
convertLineNumberTable(env, clazz,
&step->lineEntryCount, &step->lineEntries);
}
}
step->fromLine = findLineNumber(thread, location,
step->lineEntries, step->lineEntryCount);
}
} END_WITH_LOCAL_REFS(env);
}
return error;
}
/*
* TO DO: The step handlers (handleFrameChange and handleStep can
* be broken down and made simpler now that we can install and de-install event
* handlers.
*/
static void
handleFramePopEvent(JNIEnv *env, EventInfo *evinfo,
HandlerNode *node,
struct bag *eventBag)
{
StepRequest *step;
jthread thread = evinfo->thread;
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting step request");
}
if (step->pending) {
/*
* Note: current depth is reported as *before* the pending frame
* pop.
*/
jint currentDepth;
jint fromDepth;
jint afterPopDepth;
currentDepth = getFrameCount(thread);
fromDepth = step->fromStackDepth;
afterPopDepth = currentDepth-1;
LOG_STEP(("handleFramePopEvent: BEGIN fromDepth=%d, currentDepth=%d",
fromDepth, currentDepth));
/*
* If we are exiting the original stepping frame, record that
* fact here. Once the next step event comes in, we can safely
* stop stepping there.
*/
if (fromDepth > afterPopDepth ) {
step->frameExited = JNI_TRUE;
}
if (step->depth == JDWP_STEP_DEPTH(OVER)) {
/*
* Either
* 1) the original stepping frame is about to be popped
* [fromDepth == currentDepth]. Re-enable stepping to
* reach a point where we can stop.
* 2) a method called from the stepping frame has returned
* (during which we had stepping disabled)
* [fromDepth == currentDepth - 1]. Re-enable stepping
* so that we can continue instructions steps in the
* original stepping frame.
* 3) a method further down the call chain has notified
* of a frame pop [fromDepth < currentDepth - 1]. This
* *might* represent case (2) above if the stepping frame
* was calling a native method which in turn called a
* java method. If so, we must enable stepping to
* ensure that we get control back after the intervening
* native frame is popped (you can't get frame pop
* notifications on native frames). If the native caller
* calls another Java method before returning,
* stepping will be diabled again and another frame pop
* will be awaited.
*
* If it turns out that this is not case (2) with native
* methods, then the enabled stepping is benign and
* will be disabled again on the next step event.
*
* Note that the condition not covered above,
* [fromDepth > currentDepth] shouldn't happen since it means
* that too many frames have been popped. For robustness,
* we enable stepping in that case too, so that the errant
* step-over can be stopped.
*
*/
LOG_STEP(("handleFramePopEvent: starting singlestep, depth==OVER"));
enableStepping(thread);
} else if (step->depth == JDWP_STEP_DEPTH(OUT) &&
fromDepth > afterPopDepth) {
/*
* The original stepping frame is about to be popped. Step
* until we reach the next safe place to stop.
*/
LOG_STEP(("handleFramePopEvent: starting singlestep, depth==OUT && fromDepth > afterPopDepth (%d>%d)",fromDepth, afterPopDepth));
enableStepping(thread);
} else if (step->methodEnterHandlerNode != NULL &&
fromDepth >= afterPopDepth) {
/*
* We installed a method entry event handler as part of a
* step into operation. We've popped back to the original
* stepping frame without finding a place to stop.
* Resume stepping in the original frame.
*/
LOG_STEP(("handleFramePopEvent: starting singlestep, have methodEnter handler && depth==OUT && fromDepth >= afterPopDepth (%d>%d)",fromDepth, afterPopDepth));
enableStepping(thread);
(void)eventHandler_free(step->methodEnterHandlerNode);
step->methodEnterHandlerNode = NULL;
}
LOG_STEP(("handleFramePopEvent: finished"));
}
stepControl_unlock();
}
static void
handleExceptionCatchEvent(JNIEnv *env, EventInfo *evinfo,
HandlerNode *node,
struct bag *eventBag)
{
StepRequest *step;
jthread thread = evinfo->thread;
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting step request");
}
if (step->pending) {
/*
* Determine where we are on the call stack relative to where
* we started.
*/
jint currentDepth = getFrameCount(thread);
jint fromDepth = step->fromStackDepth;
LOG_STEP(("handleExceptionCatchEvent: fromDepth=%d, currentDepth=%d",
fromDepth, currentDepth));
/*
* If we are exiting the original stepping frame, record that
* fact here. Once the next step event comes in, we can safely
* stop stepping there.
*/
if (fromDepth > currentDepth) {
step->frameExited = JNI_TRUE;
}
if (step->depth == JDWP_STEP_DEPTH(OVER) &&
fromDepth >= currentDepth) {
/*
* Either the original stepping frame is done,
* or a called method has returned (during which we had stepping
* disabled). In either case we must resume stepping.
*/
enableStepping(thread);
} else if (step->depth == JDWP_STEP_DEPTH(OUT) &&
fromDepth > currentDepth) {
/*
* The original stepping frame is done. Step
* until we reach the next safe place to stop.
*/
enableStepping(thread);
} else if (step->methodEnterHandlerNode != NULL &&
fromDepth >= currentDepth) {
/*
* We installed a method entry event handler as part of a
* step into operation. We've popped back to the original
* stepping frame or higher without finding a place to stop.
* Resume stepping in the original frame.
*/
enableStepping(thread);
(void)eventHandler_free(step->methodEnterHandlerNode);
step->methodEnterHandlerNode = NULL;
}
}
stepControl_unlock();
}
static void
handleMethodEnterEvent(JNIEnv *env, EventInfo *evinfo,
HandlerNode *node,
struct bag *eventBag)
{
StepRequest *step;
jthread thread;
thread = evinfo->thread;
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting step request");
}
if (step->pending) {
jclass clazz;
jmethodID method;
char *classname;
LOG_STEP(("handleMethodEnterEvent: thread=%p", thread));
clazz = evinfo->clazz;
method = evinfo->method;
classname = getClassname(clazz);
/*
* This handler is relevant only to step into
*/
JDI_ASSERT(step->depth == JDWP_STEP_DEPTH(INTO));
if ( (!eventFilter_predictFiltering(step->stepHandlerNode,
clazz, classname))
&& ( step->granularity != JDWP_STEP_SIZE(LINE)
|| hasLineNumbers(method) ) ) {
/*
* We've found a suitable method in which to stop. Step
* until we reach the next safe location to complete the step->,
* and we can get rid of the method entry handler.
*/
enableStepping(thread);
if ( step->methodEnterHandlerNode != NULL ) {
(void)eventHandler_free(step->methodEnterHandlerNode);
step->methodEnterHandlerNode = NULL;
}
}
jvmtiDeallocate(classname);
classname = NULL;
}
stepControl_unlock();
}
static void
completeStep(JNIEnv *env, jthread thread, StepRequest *step)
{
jvmtiError error;
/*
* We've completed a step; reset state for the next one, if any
*/
LOG_STEP(("completeStep: thread=%p", thread));
if (step->methodEnterHandlerNode != NULL) {
(void)eventHandler_free(step->methodEnterHandlerNode);
step->methodEnterHandlerNode = NULL;
}
error = initState(env, thread, step);
if (error != JVMTI_ERROR_NONE) {
/*
* None of the initState errors should happen after one step
* has successfully completed.
*/
EXIT_ERROR(error, "initializing step state");
}
}
jboolean
stepControl_handleStep(JNIEnv *env, jthread thread,
jclass clazz, jmethodID method)
{
jboolean completed = JNI_FALSE;
StepRequest *step;
jint currentDepth;
jint fromDepth;
jvmtiError error;
char *classname;
classname = NULL;
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting step request");
}
/*
* If no step is currently pending, ignore the event
*/
if (!step->pending) {
goto done;
}
LOG_STEP(("stepControl_handleStep: thread=%p", thread));
/*
* We never filter step into instruction. It's always over on the
* first step event.
*/
if (step->depth == JDWP_STEP_DEPTH(INTO) &&
step->granularity == JDWP_STEP_SIZE(MIN)) {
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, into min"));
goto done;
}
/*
* If we have left the method in which
* stepping started, the step is always complete.
*/
if (step->frameExited) {
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, frame exited"));
goto done;
}
/*
* Determine where we are on the call stack relative to where
* we started.
*/
currentDepth = getFrameCount(thread);
fromDepth = step->fromStackDepth;
if (fromDepth > currentDepth) {
/*
* We have returned from the caller. There are cases where
* we don't get frame pop notifications
* (e.g. stepping from opaque frames), and that's when
* this code will be reached. Complete the step->
*/
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, fromDepth>currentDepth(%d>%d)", fromDepth, currentDepth));
} else if (fromDepth < currentDepth) {
/* We have dropped into a called method. */
if ( step->depth == JDWP_STEP_DEPTH(INTO)
&& (!eventFilter_predictFiltering(step->stepHandlerNode, clazz,
(classname = getClassname(clazz))))
&& hasLineNumbers(method) ) {
/* Stepped into a method with lines, so we're done */
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, fromDepth<currentDepth(%d<%d) and into method with lines", fromDepth, currentDepth));
} else {
/*
* We need to continue, but don't want the overhead of step
* events from this method. So, we disable stepping and
* enable a frame pop. If we're stepping into, we also
* enable method enter events because a called frame may be
* where we want to stop.
*/
disableStepping(thread);
if (step->depth == JDWP_STEP_DEPTH(INTO)) {
step->methodEnterHandlerNode =
eventHandler_createInternalThreadOnly(
EI_METHOD_ENTRY,
handleMethodEnterEvent, thread);
if (step->methodEnterHandlerNode == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,
"installing event method enter handler");
}
}
error = JVMTI_FUNC_PTR(gdata->jvmti,NotifyFramePop)
(gdata->jvmti, thread, 0);
if (error == JVMTI_ERROR_DUPLICATE) {
error = JVMTI_ERROR_NONE;
} else if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "setting up notify frame pop");
}
}
jvmtiDeallocate(classname);
classname = NULL;
} else {
/*
* We are at the same stack depth where stepping started.
* Instruction steps are complete at this point. For line
* steps we must check to see whether we've moved to a
* different line.
*/
if (step->granularity == JDWP_STEP_SIZE(MIN)) {
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, fromDepth==currentDepth(%d) and min", fromDepth));
} else {
if (step->fromLine != -1) {
jint line = -1;
jlocation location;
jmethodID method;
WITH_LOCAL_REFS(env, 1) {
jclass clazz;
error = getFrameLocation(thread,
&clazz, &method, &location);
if ( isMethodObsolete(method)) {
method = NULL;
location = -1;
}
if (error != JVMTI_ERROR_NONE || location == -1) {
EXIT_ERROR(error, "getting frame location");
}
if ( method == step->method ) {
LOG_STEP(("stepControl_handleStep: checking line location"));
log_debugee_location("stepControl_handleStep: checking line loc",
thread, method, location);
line = findLineNumber(thread, location,
step->lineEntries, step->lineEntryCount);
}
if (line != step->fromLine) {
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, fromDepth==currentDepth(%d) and different line", fromDepth));
}
} END_WITH_LOCAL_REFS(env);
} else {
/*
* This is a rare case. We have stepped from a location
* inside a native method to a location within a Java
* method at the same stack depth. This means that
* the original native method returned to another
* native method which, in turn, invoked a Java method.
*
* Since the original frame was native, we were unable
* to ask for a frame pop event, and, thus, could not
* set the step->frameExited flag when the original
* method was done. Instead we end up here
* and act just as though the frameExited flag was set
* and complete the step immediately.
*/
completed = JNI_TRUE;
LOG_STEP(("stepControl_handleStep: completed, fromDepth==currentDepth(%d) and no line", fromDepth));
}
}
LOG_STEP(("stepControl_handleStep: finished"));
}
done:
if (completed) {
completeStep(env, thread, step);
}
stepControl_unlock();
return completed;
}
void
stepControl_initialize(void)
{
stepLock = debugMonitorCreate("JDWP Step Handler Lock");
}
void
stepControl_reset(void)
{
}
/*
* Reset step control request stack depth and line number.
*/
void
stepControl_resetRequest(jthread thread)
{
StepRequest *step;
jvmtiError error;
LOG_STEP(("stepControl_resetRequest: thread=%p", thread));
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step != NULL) {
JNIEnv *env;
env = getEnv();
error = initState(env, thread, step);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "initializing step state");
}
} else {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting step request");
}
stepControl_unlock();
}
static void
initEvents(jthread thread, StepRequest *step)
{
/* Need to install frame pop handler and exception catch handler when
* single-stepping is enabled (i.e. step-into or step-over/step-out
* when fromStackDepth > 0).
*/
if (step->depth == JDWP_STEP_DEPTH(INTO) || step->fromStackDepth > 0) {
/*
* TO DO: These might be able to applied more selectively to
* boost performance.
*/
step->catchHandlerNode = eventHandler_createInternalThreadOnly(
EI_EXCEPTION_CATCH,
handleExceptionCatchEvent,
thread);
step->framePopHandlerNode = eventHandler_createInternalThreadOnly(
EI_FRAME_POP,
handleFramePopEvent,
thread);
if (step->catchHandlerNode == NULL ||
step->framePopHandlerNode == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,
"installing step event handlers");
}
}
/*
* Initially enable stepping:
* 1) For step into, always
* 2) For step over, unless right after the VM_INIT.
* Enable stepping for STEP_MIN or STEP_LINE with or without line numbers.
* If the class is redefined then non EMCP methods may not have line
* number info. So enable line stepping for non line number so that it
* behaves like STEP_MIN/STEP_OVER.
* 3) For step out, only if stepping from native, except right after VM_INIT
*
* (right after VM_INIT, a step->over or out is identical to running
* forever)
*/
switch (step->depth) {
case JDWP_STEP_DEPTH(INTO):
enableStepping(thread);
break;
case JDWP_STEP_DEPTH(OVER):
if (step->fromStackDepth > 0 && !step->fromNative ) {
enableStepping(thread);
}
break;
case JDWP_STEP_DEPTH(OUT):
if (step->fromNative &&
(step->fromStackDepth > 0)) {
enableStepping(thread);
}
break;
default:
JDI_ASSERT(JNI_FALSE);
}
}
jvmtiError
stepControl_beginStep(JNIEnv *env, jthread thread, jint size, jint depth,
HandlerNode *node)
{
StepRequest *step;
jvmtiError error;
jvmtiError error2;
LOG_STEP(("stepControl_beginStep: thread=%p,size=%d,depth=%d",
thread, size, depth));
eventHandler_lock(); /* for proper lock order */
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step == NULL) {
error = AGENT_ERROR_INVALID_THREAD;
/* Normally not getting a StepRequest struct pointer is a fatal error
* but on a beginStep, we just return an error code.
*/
} else {
/*
* In case the thread isn't already suspended, do it again.
*/
error = threadControl_suspendThread(thread, JNI_FALSE);
if (error == JVMTI_ERROR_NONE) {
/*
* Overwrite any currently executing step.
*/
step->granularity = size;
step->depth = depth;
step->catchHandlerNode = NULL;
step->framePopHandlerNode = NULL;
step->methodEnterHandlerNode = NULL;
step->stepHandlerNode = node;
error = initState(env, thread, step);
if (error == JVMTI_ERROR_NONE) {
initEvents(thread, step);
}
/* false means it is not okay to unblock the commandLoop thread */
error2 = threadControl_resumeThread(thread, JNI_FALSE);
if (error2 != JVMTI_ERROR_NONE && error == JVMTI_ERROR_NONE) {
error = error2;
}
/*
* If everything went ok, indicate a step is pending.
*/
if (error == JVMTI_ERROR_NONE) {
step->pending = JNI_TRUE;
}
} else {
EXIT_ERROR(error, "stepControl_beginStep: cannot suspend thread");
}
}
stepControl_unlock();
eventHandler_unlock();
return error;
}
static void
clearStep(jthread thread, StepRequest *step)
{
if (step->pending) {
disableStepping(thread);
if ( step->catchHandlerNode != NULL ) {
(void)eventHandler_free(step->catchHandlerNode);
step->catchHandlerNode = NULL;
}
if ( step->framePopHandlerNode!= NULL ) {
(void)eventHandler_free(step->framePopHandlerNode);
step->framePopHandlerNode = NULL;
}
if ( step->methodEnterHandlerNode != NULL ) {
(void)eventHandler_free(step->methodEnterHandlerNode);
step->methodEnterHandlerNode = NULL;
}
step->pending = JNI_FALSE;
/*
* Warning: Do not clear step->method, step->lineEntryCount,
* or step->lineEntries here, they will likely
* be needed on the next step.
*/
}
}
jvmtiError
stepControl_endStep(jthread thread)
{
StepRequest *step;
jvmtiError error;
LOG_STEP(("stepControl_endStep: thread=%p", thread));
eventHandler_lock(); /* for proper lock order */
stepControl_lock();
step = threadControl_getStepRequest(thread);
if (step != NULL) {
clearStep(thread, step);
error = JVMTI_ERROR_NONE;
} else {
/* If the stepRequest can't be gotten, then this thread no longer
* exists, just return, don't die here, this is normal at
* termination time. Return JVMTI_ERROR_NONE so the thread Ref
* can be tossed.
*/
error = JVMTI_ERROR_NONE;
}
stepControl_unlock();
eventHandler_unlock();
return error;
}
void
stepControl_clearRequest(jthread thread, StepRequest *step)
{
LOG_STEP(("stepControl_clearRequest: thread=%p", thread));
clearStep(thread, step);
}
void
stepControl_lock(void)
{
debugMonitorEnter(stepLock);
}
void
stepControl_unlock(void)
{
debugMonitorExit(stepLock);
}