llvm/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

//===-- AppleObjCRuntime.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 "AppleObjCRuntime.h"
#include "AppleObjCRuntimeV1.h"
#include "AppleObjCRuntimeV2.h"
#include "AppleObjCTrampolineHandler.h"
#include "Plugins/Language/ObjC/NSString.h"
#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
#include "Plugins/Process/Utility/HistoryThread.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/ErrorMessages.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/StreamString.h"
#include "clang/AST/Type.h"

#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

#include <vector>

usingnamespacelldb;
usingnamespacelldb_private;

LLDB_PLUGIN_DEFINE(…)

char AppleObjCRuntime::ID = …;

AppleObjCRuntime::~AppleObjCRuntime() = default;

AppleObjCRuntime::AppleObjCRuntime(Process *process)
    : … { … }

void AppleObjCRuntime::Initialize() { … }

void AppleObjCRuntime::Terminate() { … }

llvm::Error AppleObjCRuntime::GetObjectDescription(Stream &str,
                                                   ValueObject &valobj) { … }

llvm::Error
AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
                                       ExecutionContextScope *exe_scope) { … }

lldb::ModuleSP AppleObjCRuntime::GetObjCModule() { … }

Address *AppleObjCRuntime::GetPrintForDebuggerAddr() { … }

bool AppleObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) { … }

bool AppleObjCRuntime::GetDynamicTypeAndAddress(
    ValueObject &in_value, lldb::DynamicValueType use_dynamic,
    TypeAndOrName &class_type_or_name, Address &address,
    Value::ValueType &value_type) { … }

TypeAndOrName
AppleObjCRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
                                   ValueObject &static_value) { … }

bool AppleObjCRuntime::AppleIsModuleObjCLibrary(const ModuleSP &module_sp) { … }

// we use the version of Foundation to make assumptions about the ObjC runtime
// on a target
uint32_t AppleObjCRuntime::GetFoundationVersion() { … }

void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
                                                    lldb::addr_t &cf_false) { … }

bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) { … }

bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) { … }

ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread,
                                                            bool stop_others) { … }

// Static Functions
ObjCLanguageRuntime::ObjCRuntimeVersions
AppleObjCRuntime::GetObjCVersion(Process *process, ModuleSP &objc_module_sp) { … }

void AppleObjCRuntime::SetExceptionBreakpoints() { … }

void AppleObjCRuntime::ClearExceptionBreakpoints() { … }

bool AppleObjCRuntime::ExceptionBreakpointsAreSet() { … }

bool AppleObjCRuntime::ExceptionBreakpointsExplainStop(
    lldb::StopInfoSP stop_reason) { … }

bool AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing() { … }

lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() { … }

ValueObjectSP AppleObjCRuntime::GetExceptionObjectForThread(
    ThreadSP thread_sp) { … }

/// Utility method for error handling in GetBacktraceThreadFromException.
/// \param msg The message to add to the log.
/// \return An invalid ThreadSP to be returned from
///         GetBacktraceThreadFromException.
[[nodiscard]]
static ThreadSP FailExceptionParsing(llvm::StringRef msg) { … }

ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
    lldb::ValueObjectSP exception_sp) { … }

std::tuple<FileSpec, ConstString>
AppleObjCRuntime::GetExceptionThrowLocation() { … }

void AppleObjCRuntime::ReadObjCLibraryIfNeeded(const ModuleList &module_list) { … }

void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) { … }