/*
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2010-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "ThreadHandler.h"

#include <stdio.h>

#include <new>

#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <Variant.h>

#include "Architecture.h"
#include "BreakpointManager.h"
#include "CpuState.h"
#include "DebugEvent.h"
#include "DebuggerInterface.h"
#include "ExpressionInfo.h"
#include "FunctionInstance.h"
#include "ImageDebugInfo.h"
#include "InstructionInfo.h"
#include "Jobs.h"
#include "MessageCodes.h"
#include "Register.h"
#include "SignalDispositionTypes.h"
#include "SourceCode.h"
#include "SourceLanguage.h"
#include "SpecificImageDebugInfo.h"
#include "StackTrace.h"
#include "Statement.h"
#include "SyntheticPrimitiveType.h"
#include "Team.h"
#include "Tracing.h"
#include "Value.h"
#include "ValueLocation.h"
#include "Worker.h"


// step modes
enum {
        STEP_NONE,
        STEP_OVER,
        STEP_INTO,
        STEP_OUT,
        STEP_UNTIL
};


class ExpressionEvaluationListener : public ExpressionInfo::Listener {
public:
        ExpressionEvaluationListener(ThreadHandler* handler)
        :
        fHandler(handler)
        {
                fHandler->AcquireReference();
        }

        ~ExpressionEvaluationListener()
        {
                fHandler->ReleaseReference();
        }

        virtual void ExpressionEvaluated(ExpressionInfo* info, status_t result,
                ExpressionResult* value)
        {
                fHandler->_HandleBreakpointConditionEvaluated(value);
        }

private:
        ThreadHandler* fHandler;
};


ThreadHandler::ThreadHandler(::Thread* thread, Worker* worker,
        DebuggerInterface* debuggerInterface, JobListener* jobListener,
        BreakpointManager* breakpointManager)
        :
        fThread(thread),
        fWorker(worker),
        fDebuggerInterface(debuggerInterface),
        fJobListener(jobListener),
        fBreakpointManager(breakpointManager),
        fStepMode(STEP_NONE),
        fStepStatement(NULL),
        fBreakpointAddress(0),
        fSteppedOverFunctionAddress(0),
        fPreviousInstructionPointer(0),
        fPreviousFrameAddress(0),
        fSingleStepping(false),
        fConditionWaitSem(-1),
        fConditionResult(NULL)
{
        fDebuggerInterface->AcquireReference();
}


ThreadHandler::~ThreadHandler()
{
        _ClearContinuationState();
        fDebuggerInterface->ReleaseReference();

        if (fConditionWaitSem > 0)
                delete_sem(fConditionWaitSem);
}


void
ThreadHandler::Init()
{
        fWorker->ScheduleJob(new(std::nothrow) GetThreadStateJob(fDebuggerInterface,
                fThread), fJobListener);
        fConditionWaitSem = create_sem(0, "breakpoint condition waiter");
}


status_t
ThreadHandler::SetBreakpointAndRun(target_addr_t address)
{
        status_t error = _InstallTemporaryBreakpoint(address);
        if (error != B_OK)
                return error;

        fPreviousInstructionPointer = 0;
        fDebuggerInterface->ContinueThread(ThreadID());

        // Pretend "step out" mode, so that the temporary breakpoint hit will not
        // be ignored.
        fStepMode = STEP_OUT;
        fSingleStepping = false;

        return B_OK;
}


bool
ThreadHandler::HandleThreadDebugged(ThreadDebuggedEvent* event,
        const BString& stoppedReason)
{
        return _HandleThreadStopped(NULL, THREAD_STOPPED_DEBUGGED, stoppedReason);
}


bool
ThreadHandler::HandleDebuggerCall(DebuggerCallEvent* event)
{
        BString message;
        fDebuggerInterface->ReadMemoryString(event->Message(), 1024, message);
        return _HandleThreadStopped(NULL, THREAD_STOPPED_DEBUGGER_CALL, message);
}


bool
ThreadHandler::HandleBreakpointHit(BreakpointHitEvent* event)
{
        CpuState* cpuState = event->GetCpuState();
        target_addr_t instructionPointer = cpuState->InstructionPointer();

        TRACE_EVENTS("ThreadHandler::HandleBreakpointHit(): ip: %" B_PRIx64 "\n",
                instructionPointer);

        // check whether this is a temporary breakpoint we're waiting for
        if (fBreakpointAddress != 0 && instructionPointer == fBreakpointAddress
                && fStepMode != STEP_NONE) {
                if (fStepMode != STEP_UNTIL && _HandleBreakpointHitStep(cpuState))
                        return true;
        } else {
                // Might be a user breakpoint, but could as well be a temporary
                // breakpoint of another thread.
                AutoLocker<Team> locker(fThread->GetTeam());
                Breakpoint* breakpoint = fThread->GetTeam()->BreakpointAtAddress(
                        cpuState->InstructionPointer());
                bool continueThread = false;
                if (breakpoint == NULL) {
                        // spurious breakpoint -- might be a temporary breakpoint, that has
                        // already been uninstalled
                        continueThread = true;
                } else if (!breakpoint->HasEnabledUserBreakpoint()) {
                        // breakpoint of another thread or one that has been disabled in
                        // the meantime
                        continueThread = true;
                }

                if (continueThread) {
                        if (fSingleStepping) {
                                // We might have hit a just-installed software breakpoint and
                                // thus haven't stepped at all. Just try again.
                                if (fPreviousInstructionPointer == instructionPointer) {
                                        fDebuggerInterface->SingleStepThread(ThreadID());
                                        return true;
                                }

                                // That shouldn't happen. Try something reasonable anyway.
                                if (fStepMode != STEP_NONE) {
                                        if (_HandleSingleStepStep(cpuState))
                                                return true;
                                }
                        }

                        return false;
                } else {
                        locker.Unlock();
                        if (_HandleBreakpointConditionIfNeeded(cpuState))
                                return true;

                        locker.Lock();
                }
        }

        return _HandleThreadStopped(cpuState, THREAD_STOPPED_BREAKPOINT);
}


bool
ThreadHandler::HandleWatchpointHit(WatchpointHitEvent* event)
{
        return _HandleThreadStopped(event->GetCpuState(),
                THREAD_STOPPED_WATCHPOINT);
}


bool
ThreadHandler::HandleSingleStep(SingleStepEvent* event)
{
        // Check whether we're stepping automatically.
        if (fStepMode != STEP_NONE) {
                if (_HandleSingleStepStep(event->GetCpuState()))
                        return true;
        }

        return _HandleThreadStopped(event->GetCpuState(),
                THREAD_STOPPED_SINGLE_STEP);
}


bool
ThreadHandler::HandleExceptionOccurred(ExceptionOccurredEvent* event)
{
        char buffer[256];
        get_debug_exception_string(event->Exception(), buffer, sizeof(buffer));
        return _HandleThreadStopped(NULL, THREAD_STOPPED_EXCEPTION, buffer);
}


bool
ThreadHandler::HandleSignalReceived(SignalReceivedEvent* event)
{
        ::Team* team = fThread->GetTeam();
        AutoLocker<Team> locker(team);

        const SignalInfo& info = event->GetSignalInfo();
        int32 signal = info.Signal();
        int32 disposition = team->SignalDispositionFor(signal);

        switch (disposition) {
                case SIGNAL_DISPOSITION_IGNORE:
                        return false;
                case SIGNAL_DISPOSITION_STOP_AT_SIGNAL_HANDLER:
                {
                        const struct sigaction& handlerInfo = info.Handler();
                        target_addr_t address = 0;
                        if ((handlerInfo.sa_flags & SA_SIGINFO) != 0)
                                address = (target_addr_t)handlerInfo.sa_sigaction;
                        else
                                address = (target_addr_t)handlerInfo.sa_handler;

                        if (address == (target_addr_t)SIG_DFL
                                || address == (target_addr_t)SIG_IGN
                                || address == (target_addr_t)SIG_HOLD) {
                                address = 0;
                        }

                        if (address != 0 && _InstallTemporaryBreakpoint(address) == B_OK
                                && fDebuggerInterface->ContinueThread(ThreadID()) == B_OK) {
                                fStepMode = STEP_UNTIL;
                                return true;
                        }

                        // fall through if no handler or if we failed to
                        // set a breakpoint at the handler
                }
                case SIGNAL_DISPOSITION_STOP_AT_RECEIPT:
                {
                        BString stopReason;
                        stopReason.SetToFormat("Received signal %" B_PRId32 " (%s)",
                                signal, strsignal(signal));
                        return _HandleThreadStopped(NULL, THREAD_STOPPED_DEBUGGED,
                                stopReason);
                }
                default:
                        break;
        }

        return false;
}


void
ThreadHandler::HandleThreadAction(uint32 action, target_addr_t address)
{
        AutoLocker<Team> locker(fThread->GetTeam());

        if (fThread->State() == THREAD_STATE_UNKNOWN)
                return;

        // When stop is requested, thread must be running, otherwise stopped.
        if (action == MSG_THREAD_STOP
                        ? fThread->State() != THREAD_STATE_RUNNING
                        : fThread->State() != THREAD_STATE_STOPPED) {
                return;
        }

        // When stepping we need a stack trace. Save it before unsetting the state.
        CpuState* cpuState = fThread->GetCpuState();
        StackTrace* stackTrace = fThread->GetStackTrace();
        BReference<CpuState> cpuStateReference(cpuState);
        BReference<StackTrace> stackTraceReference(stackTrace);

        if (action == MSG_THREAD_SET_ADDRESS) {
                _HandleSetAddress(cpuState, address);
                return;
        }

        // When continuing the thread update thread state before actually issuing
        // the command, since we need to unlock.
        if (action != MSG_THREAD_STOP) {
                _SetThreadState(THREAD_STATE_RUNNING, NULL, THREAD_STOPPED_UNKNOWN,
                        BString());
        }

        locker.Unlock();

        switch (action) {
                case MSG_THREAD_RUN:
                        fStepMode = address != 0 ? STEP_UNTIL : STEP_NONE;
                        if (address != 0)
                                _InstallTemporaryBreakpoint(address);
                        _RunThread(0);
                        return;
                case MSG_THREAD_STOP:
                        fStepMode = STEP_NONE;
                        if (fDebuggerInterface->StopThread(ThreadID()) == B_OK)
                                fThread->SetStopRequestPending();
                        return;
                case MSG_THREAD_STEP_OVER:
                case MSG_THREAD_STEP_INTO:
                case MSG_THREAD_STEP_OUT:
                        break;
        }

        TRACE_CONTROL("ThreadHandler::HandleThreadAction(MSG_THREAD_STEP_*)\n");

        // We want to step. We need a stack trace for that purpose. If we don't
        // have one yet, get it. Start with the CPU state.
        if (stackTrace == NULL && cpuState == NULL) {
                if (fDebuggerInterface->GetCpuState(fThread->ID(), cpuState) == B_OK)
                        cpuStateReference.SetTo(cpuState, true);
        }

        if (stackTrace == NULL && cpuState != NULL) {
                if (fDebuggerInterface->GetArchitecture()->CreateStackTrace(
                                fThread->GetTeam(), this, cpuState, stackTrace, NULL, 1,
                                false, false) == B_OK) {
                        stackTraceReference.SetTo(stackTrace, true);
                }
        }

        if (stackTrace == NULL || stackTrace->CountFrames() == 0) {
                _StepFallback();
                return;
        }

        StackFrame* frame = stackTrace->FrameAt(0);

        TRACE_CONTROL("  ip: %#" B_PRIx64 "\n", frame->InstructionPointer());

        target_addr_t frameIP = frame->GetCpuState()->InstructionPointer();
        // When the thread is in a syscall, do the same for all step kinds: Stop it
        // when it returns by means of a breakpoint.
        if (frame->Type() == STACK_FRAME_TYPE_SYSCALL) {
                // set a breakpoint at the CPU state's instruction pointer (points to
                // the return address, unlike the stack frame's instruction pointer)
// TODO: This is doesn't work correctly anymore. When stepping over a "syscall"
// instruction the thread is stopped twice. The after the first step the PC is
// incorrectly shown at the "syscall" instruction. Then we step again and are
// stopped at the temporary breakpoint after the "syscall" instruction. There
// are two problems. The first one is that we don't (cannot?) discriminate
// between the thread being in a syscall (like in a blocking syscall) and the
// thread having been stopped (or singled-stepped) at the end of the syscall.
// The second issue is that the temporary breakpoint is probably not necessary
// anymore, since single-stepping over "syscall" instructions should just work
// as expected.
                status_t error = _InstallTemporaryBreakpoint(frameIP);
                if (error != B_OK) {
                        _StepFallback();
                        return;
                }

                fStepMode = STEP_OUT;
                _RunThread(frameIP);
                return;
        }

        // For "step out" just set a temporary breakpoint on the return address.
        if (action == MSG_THREAD_STEP_OUT) {
                status_t error = _InstallTemporaryBreakpoint(frame->ReturnAddress());
                if (error != B_OK) {
                        _StepFallback();
                        return;
                }
                fPreviousInstructionPointer = frameIP;
                fPreviousFrameAddress = frame->FrameAddress();
                fStepMode = STEP_OUT;
                _RunThread(frameIP);
                return;
        }

        // For "step in" and "step over" we also need the source code statement at
        // the current instruction pointer.
        fStepStatement = _GetStatementAtInstructionPointer(frame);
        if (fStepStatement == NULL) {
                _StepFallback();
                return;
        }

        TRACE_CONTROL("  statement: %#" B_PRIx64 " - %#" B_PRIx64 "\n",
                fStepStatement->CoveringAddressRange().Start(),
                fStepStatement->CoveringAddressRange().End());

        if (action == MSG_THREAD_STEP_INTO) {
                // step into
                fStepMode = STEP_INTO;
                _SingleStepThread(frameIP);
        } else {
                fPreviousFrameAddress = frame->FrameAddress();
                // step over
                fStepMode = STEP_OVER;
                if (!_DoStepOver(frame->GetCpuState()))
                        _StepFallback();
        }
}


void
ThreadHandler::HandleThreadStateChanged()
{
        AutoLocker<Team> locker(fThread->GetTeam());

        // cancel jobs for this thread
        fWorker->AbortJob(SimpleJobKey(fThread, JOB_TYPE_GET_CPU_STATE));
        fWorker->AbortJob(SimpleJobKey(fThread, JOB_TYPE_GET_STACK_TRACE));

        // If the thread is stopped and has no CPU state yet, schedule a job.
        if (fThread->State() == THREAD_STATE_STOPPED
                        && fThread->GetCpuState() == NULL) {
                fWorker->ScheduleJob(
                        new(std::nothrow) GetCpuStateJob(fDebuggerInterface, fThread),
                        fJobListener);
        }
}


void
ThreadHandler::HandleCpuStateChanged()
{
        AutoLocker<Team> locker(fThread->GetTeam());

        // cancel stack trace job for this thread
        fWorker->AbortJob(SimpleJobKey(fThread, JOB_TYPE_GET_STACK_TRACE));

        // If the thread has a CPU state, but no stack trace yet, schedule a job.
        if (fThread->GetCpuState() != NULL && fThread->GetStackTrace() == NULL) {
                fWorker->ScheduleJob(
                        new(std::nothrow) GetStackTraceJob(fDebuggerInterface,
                                fJobListener, fDebuggerInterface->GetArchitecture(),
                                fThread), fJobListener);
        }
}


void
ThreadHandler::HandleStackTraceChanged()
{
}


status_t
ThreadHandler::GetImageDebugInfo(Image* image, ImageDebugInfo*& _info)
{
        AutoLocker<Team> teamLocker(fThread->GetTeam());

        if (image->GetImageDebugInfo() != NULL) {
                _info = image->GetImageDebugInfo();
                _info->AcquireReference();
                return B_OK;
        }

        // Let's be lazy. If the image debug info has not been loaded yet, the user
        // can't have seen any source code either.
        return B_ENTRY_NOT_FOUND;
}


bool
ThreadHandler::_HandleThreadStopped(CpuState* cpuState, uint32 stoppedReason,
        const BString& stoppedReasonInfo)
{
        _ClearContinuationState();

        AutoLocker<Team> locker(fThread->GetTeam());

        _SetThreadState(THREAD_STATE_STOPPED, cpuState, stoppedReason,
                stoppedReasonInfo);

        return true;
}


bool
ThreadHandler::_HandleSetAddress(CpuState* state, target_addr_t address)
{
        CpuState* newState = NULL;
        if (state->Clone(newState) != B_OK)
                return false;
        BReference<CpuState> stateReference(newState, true);

        newState->SetInstructionPointer(address);
        if (fDebuggerInterface->SetCpuState(fThread->ID(), newState) != B_OK)
                return false;

        AutoLocker<Team> locker(fThread->GetTeam());
        fThread->SetStackTrace(NULL);
        fThread->SetCpuState(newState);

        return true;
}


void
ThreadHandler::_SetThreadState(uint32 state, CpuState* cpuState,
        uint32 stoppedReason, const BString& stoppedReasonInfo)
{
        fThread->SetState(state, stoppedReason, stoppedReasonInfo);
        fThread->SetCpuState(cpuState);
}


Statement*
ThreadHandler::_GetStatementAtInstructionPointer(StackFrame* frame)
{
        AutoLocker<Team> locker(fThread->GetTeam());

        FunctionInstance* functionInstance = frame->Function();
        if (functionInstance == NULL)
                return NULL;
        FunctionDebugInfo* function = functionInstance->GetFunctionDebugInfo();

        // If there's source code attached to the function, we can just get the
        // statement.
//      SourceCode* sourceCode = function->GetSourceCode();
//      if (sourceCode != NULL) {
//              Statement* statement = sourceCode->StatementAtAddress(
//                      frame->InstructionPointer());
//              if (statement != NULL)
//                      statement->AcquireReference();
//              return statement;
//      }

        locker.Unlock();

        // We need to get the statement from the debug info of the function.
        Statement* statement;
        if (function->GetSpecificImageDebugInfo()->GetStatement(function,
                        frame->InstructionPointer(), statement) != B_OK) {
                return NULL;
        }

        return statement;
}


void
ThreadHandler::_StepFallback()
{
        fStepMode = STEP_NONE;
        _SingleStepThread(0);
}


bool
ThreadHandler::_DoStepOver(CpuState* cpuState)
{
        TRACE_CONTROL("ThreadHandler::_DoStepOver()\n");

        // The basic strategy is to single-step out of the statement like for
        // "step into", only we have to avoid stepping into subroutines. Hence we
        // check whether the current instruction is a subroutine call. If not, we
        // just single-step, otherwise we set a breakpoint after the instruction.
        InstructionInfo info;
        if (fDebuggerInterface->GetArchitecture()->GetInstructionInfo(
                        cpuState->InstructionPointer(), info, cpuState) != B_OK) {
                TRACE_CONTROL("  failed to get instruction info\n");
                return false;
        }

        if (info.Type() != INSTRUCTION_TYPE_SUBROUTINE_CALL) {
                _SingleStepThread(cpuState->InstructionPointer());

                TRACE_CONTROL("  not a subroutine call\n");
                return true;
        }

        TRACE_CONTROL("  subroutine call -- installing breakpoint at address "
                "%#" B_PRIx64 "\n", info.Address() + info.Size());

        if (_InstallTemporaryBreakpoint(info.Address() + info.Size()) != B_OK)
                return false;

        fSteppedOverFunctionAddress = info.TargetAddress();

        _RunThread(cpuState->InstructionPointer());
        return true;
}


status_t
ThreadHandler::_InstallTemporaryBreakpoint(target_addr_t address)
{
        _UninstallTemporaryBreakpoint();

        status_t error = fBreakpointManager->InstallTemporaryBreakpoint(address,
                this);
        if (error != B_OK)
                return error;

        fBreakpointAddress = address;
        return B_OK;
}


void
ThreadHandler::_UninstallTemporaryBreakpoint()
{
        if (fBreakpointAddress == 0)
                return;

        fBreakpointManager->UninstallTemporaryBreakpoint(fBreakpointAddress, this);
        fBreakpointAddress = 0;
}


void
ThreadHandler::_ClearContinuationState()
{
        _UninstallTemporaryBreakpoint();

        if (fStepStatement != NULL) {
                fStepStatement->ReleaseReference();
                fStepStatement = NULL;
        }

        fStepMode = STEP_NONE;
        fSingleStepping = false;
}


void
ThreadHandler::_RunThread(target_addr_t instructionPointer)
{
        fPreviousInstructionPointer = instructionPointer;
        fDebuggerInterface->ContinueThread(ThreadID());
        fSingleStepping = false;
}


void
ThreadHandler::_SingleStepThread(target_addr_t instructionPointer)
{
        fPreviousInstructionPointer = instructionPointer;
        fDebuggerInterface->SingleStepThread(ThreadID());
        fSingleStepping = true;
}


bool
ThreadHandler::_HandleBreakpointHitStep(CpuState* cpuState)
{
        // in any case uninstall the temporary breakpoint
        _UninstallTemporaryBreakpoint();

        switch (fStepMode) {
                case STEP_OVER:
                {
                        StackTrace* stackTrace = fThread->GetStackTrace();
                        BReference<StackTrace> stackTraceReference(stackTrace);

                        if (stackTrace == NULL && cpuState != NULL) {
                                if (fDebuggerInterface->GetArchitecture()->CreateStackTrace(
                                                fThread->GetTeam(), this, cpuState, stackTrace, NULL,
                                                1, false, false) == B_OK) {
                                        stackTraceReference.SetTo(stackTrace, true);
                                }
                        }
                        if (stackTrace != NULL) {
                                StackFrame* frame = stackTrace->FrameAt(0);
                                // If we're not in the same frame we started in,
                                // keep executing.
                                if (frame != NULL && fPreviousFrameAddress
                                                != frame->FrameAddress()) {
                                        status_t error = _InstallTemporaryBreakpoint(
                                                cpuState->InstructionPointer());
                                        if (error != B_OK)
                                                _StepFallback();
                                        else
                                                _RunThread(cpuState->InstructionPointer());
                                        return true;
                                }
                        }

                        if (fPreviousFrameAddress != 0 && fSteppedOverFunctionAddress != 0
                                        && fSteppedOverFunctionAddress != cpuState->InstructionPointer()) {
                                TRACE_CONTROL("STEP_OVER: called function address %#" B_PRIx64
                                        ", previous frame address: %#" B_PRIx64 ", frame address: %#"
                                        B_PRIx64 ", adding return info\n", fSteppedOverFunctionAddress,
                                        fPreviousFrameAddress, stackTrace->FrameAt(0)->FrameAddress());
                                ReturnValueInfo* returnInfo = new(std::nothrow) ReturnValueInfo(
                                        fSteppedOverFunctionAddress, cpuState);
                                if (returnInfo == NULL)
                                        return false;

                                BReference<ReturnValueInfo> returnInfoReference(returnInfo, true);

                                if (fThread->AddReturnValueInfo(returnInfo) != B_OK)
                                        return false;

                                returnInfoReference.Detach();
                                fSteppedOverFunctionAddress = 0;
                        }

                        // If we're still in the statement, we continue single-stepping,
                        // otherwise we're done.
                        if (fStepStatement->ContainsAddress(
                                        cpuState->InstructionPointer())) {
                                if (!_DoStepOver(cpuState))
                                        _StepFallback();
                                return true;
                        }
                        fPreviousFrameAddress = 0;
                        return false;
                }

                case STEP_INTO:
                        // Should never happen -- we don't set a breakpoint in this case.
                        return false;

                case STEP_OUT:
                {
                        // That's the return address, so we're done in theory,
                        // unless we're a recursive function. Check if we've actually
                        // exited the previous stack frame or not
                        if (!_HasExitedFrame(cpuState->StackFramePointer())) {
                                status_t error = _InstallTemporaryBreakpoint(
                                        cpuState->InstructionPointer());
                                if (error != B_OK)
                                        _StepFallback();
                                else
                                        _RunThread(cpuState->InstructionPointer());
                                return true;
                        }

                        if (fPreviousFrameAddress == 0)
                                return false;

                        TRACE_CONTROL("ThreadHandler::_HandleBreakpointHitStep() - "
                                "frame pointer 0x%#" B_PRIx64 ", previous: 0x%#" B_PRIx64
                                " - step out adding return value\n", cpuState
                                        ->StackFramePointer(), fPreviousFrameAddress);
                        ReturnValueInfo* info = new(std::nothrow) ReturnValueInfo(
                                fPreviousInstructionPointer, cpuState);
                        if (info == NULL)
                                return false;
                        BReference<ReturnValueInfo> infoReference(info, true);
                        if (fThread->AddReturnValueInfo(info) != B_OK)
                                return false;

                        infoReference.Detach();
                        fPreviousFrameAddress = 0;
                }

                default:
                        return false;
        }
}


bool
ThreadHandler::_HandleSingleStepStep(CpuState* cpuState)
{
        TRACE_CONTROL("ThreadHandler::_HandleSingleStepStep(): ip: %" B_PRIx64 "\n",
                cpuState->InstructionPointer());

        switch (fStepMode) {
                case STEP_INTO:
                {
                        // We continue stepping as long as we're in the statement.
                        if (fStepStatement->ContainsAddress(cpuState->InstructionPointer())) {
                                _SingleStepThread(cpuState->InstructionPointer());
                                return true;
                        }

                        StackTrace* stackTrace = fThread->GetStackTrace();
                        BReference<StackTrace> stackTraceReference(stackTrace);

                        if (stackTrace == NULL && cpuState != NULL) {
                                if (fDebuggerInterface->GetArchitecture()->CreateStackTrace(
                                                fThread->GetTeam(), this, cpuState, stackTrace, NULL,
                                                1, false, false) == B_OK) {
                                        stackTraceReference.SetTo(stackTrace, true);
                                }
                        }

                        if (stackTrace != NULL) {
                                StackFrame* frame = stackTrace->FrameAt(0);
                                Image* image = frame->GetImage();
                                if (image == NULL)
                                        return false;

                                ImageDebugInfo* info = NULL;
                                if (GetImageDebugInfo(image, info) != B_OK)
                                        return false;

                                BReference<ImageDebugInfo>(info, true);
                                if (info->GetAddressSectionType(
                                                cpuState->InstructionPointer())
                                                == ADDRESS_SECTION_TYPE_PLT) {
                                        _SingleStepThread(cpuState->InstructionPointer());
                                        return true;
                                }
                        }
                        return false;
                }

                case STEP_OVER:
                {
                        // If we have stepped out of the statement, we're done.
                        if (!fStepStatement->ContainsAddress(cpuState->InstructionPointer())) {
                                StackTrace* stackTrace = fThread->GetStackTrace();
                                BReference<StackTrace> stackTraceReference(stackTrace);
                                if (stackTrace == NULL && cpuState != NULL) {
                                        if (fDebuggerInterface->GetArchitecture()->CreateStackTrace(
                                                        fThread->GetTeam(), this, cpuState, stackTrace,
                                                        NULL, 1, false, false) == B_OK) {
                                                stackTraceReference.SetTo(stackTrace, true);
                                        }
                                }


                                if (stackTrace != NULL) {
                                        if (_HasExitedFrame(stackTrace->FrameAt(0)
                                                ->FrameAddress())) {
                                                TRACE_CONTROL("ThreadHandler::_HandleSingleStepStep() "
                                                        " - adding return value for STEP_OVER\n");
                                                ReturnValueInfo* info = new(std::nothrow)
                                                        ReturnValueInfo(fStepStatement
                                                                ->CoveringAddressRange().Start(), cpuState);
                                                if (info == NULL)
                                                        return false;
                                                BReference<ReturnValueInfo> infoReference(info, true);
                                                if (fThread->AddReturnValueInfo(info) != B_OK)
                                                        return false;

                                                infoReference.Detach();
                                        }
                                }
                                return false;
                        }
                        return _DoStepOver(cpuState);
                }

                case STEP_OUT:
                        // We never single-step in this case.
                default:
                        return false;
        }
}


bool
ThreadHandler::_HandleBreakpointConditionIfNeeded(CpuState* cpuState)
{
        AutoLocker< ::Team> teamLocker(fThread->GetTeam());
        Breakpoint* breakpoint = fThread->GetTeam()->BreakpointAtAddress(
                cpuState->InstructionPointer());

        if (breakpoint == NULL)
                return false;

        if (!breakpoint->HasEnabledUserBreakpoint())
                return false;

        const UserBreakpointInstanceList& breakpoints
                = breakpoint->UserBreakpoints();

        for (UserBreakpointInstanceList::ConstIterator it
                        = breakpoints.GetIterator(); it.HasNext();) {
                UserBreakpoint* userBreakpoint = it.Next()->GetUserBreakpoint();
                if (!userBreakpoint->IsValid())
                        continue;
                if (!userBreakpoint->IsEnabled())
                        continue;
                if (!userBreakpoint->HasCondition())
                        continue;

                StackTrace* stackTrace = fThread->GetStackTrace();
                BReference<StackTrace> stackTraceReference;
                if (stackTrace == NULL) {
                        if (fDebuggerInterface->GetArchitecture()->CreateStackTrace(
                                fThread->GetTeam(), this, cpuState, stackTrace, NULL, 1,
                                false, true) == B_OK) {
                                stackTraceReference.SetTo(stackTrace, true);
                        } else
                                return false;
                }

                StackFrame* frame = stackTrace->FrameAt(0);
                FunctionDebugInfo* info = frame->Function()->GetFunctionDebugInfo();
                if (info == NULL)
                        return false;

                SpecificImageDebugInfo* specificInfo
                        = info->GetSpecificImageDebugInfo();
                if (specificInfo == NULL)
                        return false;

                SourceLanguage* language;
                if (specificInfo->GetSourceLanguage(info, language) != B_OK)
                        return false;

                BReference<SourceLanguage> reference(language, true);
                ExpressionEvaluationListener* listener
                        = new(std::nothrow) ExpressionEvaluationListener(this);
                if (listener == NULL)
                        return false;

                ExpressionInfo* expressionInfo = new(std::nothrow) ExpressionInfo(
                        userBreakpoint->Condition());

                if (expressionInfo == NULL) {
                        delete listener;
                        return false;
                }

                BReference<ExpressionInfo> expressionReference(expressionInfo, true);

                expressionInfo->AddListener(listener);

                status_t error = fWorker->ScheduleJob(
                        new(std::nothrow) ExpressionEvaluationJob(fThread->GetTeam(),
                                fDebuggerInterface, language, expressionInfo, frame, fThread),
                        fJobListener);

                BPrivate::ObjectDeleter<ExpressionEvaluationListener> deleter(
                        listener);
                if (error == B_OK) {
                        teamLocker.Unlock();
                        do {
                                error = acquire_sem(fConditionWaitSem);
                        } while (error == B_INTERRUPTED);

                        teamLocker.Lock();

                        if (_CheckStopCondition()) {
                                if (fConditionResult != NULL) {
                                        fConditionResult->ReleaseReference();
                                        fConditionResult = NULL;
                                }
                                _SetThreadState(THREAD_STATE_STOPPED, cpuState,
                                        THREAD_STOPPED_BREAKPOINT, BString());
                                return false;
                        } else {
                                fDebuggerInterface->ContinueThread(ThreadID());
                                return true;
                        }
                }
        }

        return false;
}


void
ThreadHandler::_HandleBreakpointConditionEvaluated(ExpressionResult* value)
{
        fConditionResult = value;
        if (fConditionResult != NULL)
                fConditionResult->AcquireReference();
        release_sem(fConditionWaitSem);
}


bool
ThreadHandler::_CheckStopCondition()
{
        // if we we're unable to properly assess the expression result
        // in any way, fall back to behaving like an unconditional breakpoint.
        if (fConditionResult == NULL)
                return true;

        if (fConditionResult->Kind() != EXPRESSION_RESULT_KIND_PRIMITIVE)
                return true;

        BVariant value;
        if (!fConditionResult->PrimitiveValue()->ToVariant(value))
                return true;

        return value.ToBool();
}


bool
ThreadHandler::_HasExitedFrame(target_addr_t framePointer) const
{
        return fDebuggerInterface->GetArchitecture()->StackGrowthDirection()
                        == STACK_GROWTH_DIRECTION_POSITIVE
                                ? framePointer < fPreviousFrameAddress
                                : framePointer > fPreviousFrameAddress;
}