llvm/lldb/source/Host/common/NativeProcessProtocol.cpp

//===-- NativeProcessProtocol.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 "lldb/Host/common/NativeProcessProtocol.h"
#include "lldb/Host/Host.h"
#include "lldb/Host/common/NativeBreakpointList.h"
#include "lldb/Host/common/NativeRegisterContext.h"
#include "lldb/Host/common/NativeThreadProtocol.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/State.h"
#include "lldb/lldb-enumerations.h"

#include "llvm/Support/Process.h"
#include <optional>

usingnamespacelldb;
usingnamespacelldb_private;

// NativeProcessProtocol Members

NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
                                             NativeDelegate &delegate)
    : … { … }

lldb_private::Status NativeProcessProtocol::Interrupt() { … }

Status NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) { … }

lldb_private::Status
NativeProcessProtocol::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                           MemoryRegionInfo &range_info) { … }

lldb_private::Status
NativeProcessProtocol::ReadMemoryTags(int32_t type, lldb::addr_t addr,
                                      size_t len, std::vector<uint8_t> &tags) { … }

lldb_private::Status
NativeProcessProtocol::WriteMemoryTags(int32_t type, lldb::addr_t addr,
                                       size_t len,
                                       const std::vector<uint8_t> &tags) { … }

std::optional<WaitStatus> NativeProcessProtocol::GetExitStatus() { … }

bool NativeProcessProtocol::SetExitStatus(WaitStatus status,
                                          bool bNotifyStateChange) { … }

NativeThreadProtocol *NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) { … }

NativeThreadProtocol *
NativeProcessProtocol::GetThreadByIDUnlocked(lldb::tid_t tid) { … }

NativeThreadProtocol *NativeProcessProtocol::GetThreadByID(lldb::tid_t tid) { … }

bool NativeProcessProtocol::IsAlive() const { … }

const NativeWatchpointList::WatchpointMap &
NativeProcessProtocol::GetWatchpointMap() const { … }

std::optional<std::pair<uint32_t, uint32_t>>
NativeProcessProtocol::GetHardwareDebugSupportInfo() const { … }

Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
                                            uint32_t watch_flags,
                                            bool hardware) { … }

Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) { … }

const HardwareBreakpointMap &
NativeProcessProtocol::GetHardwareBreakpointMap() const { … }

Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
                                                    size_t size) { … }

Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) { … }

void NativeProcessProtocol::SynchronouslyNotifyProcessStateChanged(
    lldb::StateType state) { … }

void NativeProcessProtocol::NotifyDidExec() { … }

Status NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
                                                    uint32_t size_hint) { … }

Status NativeProcessProtocol::RemoveSoftwareBreakpoint(lldb::addr_t addr) { … }

llvm::Expected<NativeProcessProtocol::SoftwareBreakpoint>
NativeProcessProtocol::EnableSoftwareBreakpoint(lldb::addr_t addr,
                                                uint32_t size_hint) { … }

llvm::Expected<llvm::ArrayRef<uint8_t>>
NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_t size_hint) { … }

size_t NativeProcessProtocol::GetSoftwareBreakpointPCOffset() { … }

void NativeProcessProtocol::FixupBreakpointPCAsNeeded(
    NativeThreadProtocol &thread) { … }

Status NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
                                               bool hardware) { … }

Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
                                                    void *buf, size_t size,
                                                    size_t &bytes_read) { … }

llvm::Expected<llvm::StringRef>
NativeProcessProtocol::ReadCStringFromMemory(lldb::addr_t addr, char *buffer,
                                             size_t max_size,
                                             size_t &total_bytes_read) { … }

lldb::StateType NativeProcessProtocol::GetState() const { … }

void NativeProcessProtocol::SetState(lldb::StateType state,
                                     bool notify_delegates) { … }

uint32_t NativeProcessProtocol::GetStopID() const { … }

void NativeProcessProtocol::DoStopIDBumped(uint32_t /* newBumpId */) { … }

NativeProcessProtocol::Manager::~Manager() = default;