llvm/lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

//===-- ScriptedProcess.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 "ScriptedProcess.h"

#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"

#include "lldb/Host/OptionParser.h"
#include "lldb/Host/ThreadLauncher.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionArgParser.h"
#include "lldb/Interpreter/OptionGroupBoolean.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Queue.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/ScriptedMetadata.h"
#include "lldb/Utility/State.h"

#include <mutex>

LLDB_PLUGIN_DEFINE(…)

usingnamespacelldb;
usingnamespacelldb_private;

llvm::StringRef ScriptedProcess::GetPluginDescriptionStatic() { … }

static constexpr lldb::ScriptLanguage g_supported_script_languages[] = …;

bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) { … }

lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
                                                lldb::ListenerSP listener_sp,
                                                const FileSpec *file,
                                                bool can_connect) { … }

bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
                               bool plugin_specified_by_name) { … }

ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
                                 lldb::ListenerSP listener_sp,
                                 const ScriptedMetadata &scripted_metadata,
                                 Status &error)
    : … { … }

ScriptedProcess::~ScriptedProcess() { … }

void ScriptedProcess::Initialize() { … }

void ScriptedProcess::Terminate() { … }

Status ScriptedProcess::DoLoadCore() { … }

Status ScriptedProcess::DoLaunch(Module *exe_module,
                                 ProcessLaunchInfo &launch_info) { … }

void ScriptedProcess::DidLaunch() { … }

void ScriptedProcess::DidResume() { … }

Status ScriptedProcess::DoResume() { … }

Status ScriptedProcess::DoAttach(const ProcessAttachInfo &attach_info) { … }

Status
ScriptedProcess::DoAttachToProcessWithID(lldb::pid_t pid,
                                         const ProcessAttachInfo &attach_info) { … }

Status ScriptedProcess::DoAttachToProcessWithName(
    const char *process_name, const ProcessAttachInfo &attach_info) { … }

void ScriptedProcess::DidAttach(ArchSpec &process_arch) { … }

Status ScriptedProcess::DoDestroy() { … }

bool ScriptedProcess::IsAlive() { … }

size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                     Status &error) { … }

size_t ScriptedProcess::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
                                      size_t size, Status &error) { … }

Status ScriptedProcess::EnableBreakpointSite(BreakpointSite *bp_site) { … }

ArchSpec ScriptedProcess::GetArchitecture() { … }

Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                              MemoryRegionInfo &region) { … }

Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos &region_list) { … }

void ScriptedProcess::Clear() { … }

bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
                                         ThreadList &new_thread_list) { … }

void ScriptedProcess::RefreshStateAfterStop() { … }

bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) { … }

lldb_private::StructuredData::ObjectSP
ScriptedProcess::GetLoadedDynamicLibrariesInfos() { … }

lldb_private::StructuredData::DictionarySP ScriptedProcess::GetMetadata() { … }

void ScriptedProcess::UpdateQueueListIfNeeded() { … }

ScriptedProcessInterface &ScriptedProcess::GetInterface() const { … }

void *ScriptedProcess::GetImplementation() { … }