llvm/lldb/source/Target/StopInfo.cpp

//===-- StopInfo.cpp ------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include <string>

#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/WatchpointResource.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h"

usingnamespacelldb;
usingnamespacelldb_private;

StopInfo::StopInfo(Thread &thread, uint64_t value)
    : … { … }

bool StopInfo::IsValid() const { … }

void StopInfo::MakeStopInfoValid() { … }

bool StopInfo::HasTargetRunSinceMe() { … }

// StopInfoBreakpoint

namespace lldb_private {
class StopInfoBreakpoint : public StopInfo { … };

// StopInfoWatchpoint

class StopInfoWatchpoint : public StopInfo { … };

// StopInfoUnixSignal

class StopInfoUnixSignal : public StopInfo { … };

// StopInfoInterrupt

class StopInfoInterrupt : public StopInfo { … };

// StopInfoTrace

class StopInfoTrace : public StopInfo { … };

// StopInfoException

class StopInfoException : public StopInfo { … };

// StopInfoProcessorTrace

class StopInfoProcessorTrace : public StopInfo { … };

// StopInfoThreadPlan

class StopInfoThreadPlan : public StopInfo { … };

// StopInfoExec

class StopInfoExec : public StopInfo { … };

// StopInfoFork

class StopInfoFork : public StopInfo { … };

// StopInfoVFork

class StopInfoVFork : public StopInfo { … };

// StopInfoVForkDone

class StopInfoVForkDone : public StopInfo { … };

} // namespace lldb_private

StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
                                                          break_id_t break_id) { … }

StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
                                                          break_id_t break_id,
                                                          bool should_stop) { … }

// LWP_TODO: We'll need a CreateStopReasonWithWatchpointResourceID akin
// to CreateStopReasonWithBreakpointSiteID
StopInfoSP StopInfo::CreateStopReasonWithWatchpointID(Thread &thread,
                                                      break_id_t watch_id,
                                                      bool silently_continue) { … }

StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
                                                const char *description,
                                                std::optional<int> code) { … }

StopInfoSP StopInfo::CreateStopReasonWithInterrupt(Thread &thread, int signo,
                                                   const char *description) { … }

StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) { … }

StopInfoSP StopInfo::CreateStopReasonWithPlan(
    ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
    ExpressionVariableSP expression_variable_sp) { … }

StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
                                                   const char *description) { … }

StopInfoSP StopInfo::CreateStopReasonProcessorTrace(Thread &thread,
                                                    const char *description) { … }

StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) { … }

StopInfoSP StopInfo::CreateStopReasonFork(Thread &thread,
                                          lldb::pid_t child_pid,
                                          lldb::tid_t child_tid) { … }


StopInfoSP StopInfo::CreateStopReasonVFork(Thread &thread,
                                           lldb::pid_t child_pid,
                                           lldb::tid_t child_tid) { … }

StopInfoSP StopInfo::CreateStopReasonVForkDone(Thread &thread) { … }

ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) { … }

ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) { … }

lldb::ValueObjectSP
StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp,
                                 lldb::addr_t *crashing_address) { … }