927 lines
30 KiB
C
927 lines
30 KiB
C
/*
|
|
* 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);
|
|
}
|