NSDictionary.cpp | Explore in Territory

//===-- NSDictionary.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 <mutex>

#include "clang/AST/DeclCXX.h"

#include "CFBasicHash.h"
#include "NSDictionary.h"

#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/FormattersHelpers.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"

usingnamespacelldb;
usingnamespacelldb_private;
usingnamespacelldb_private::formatters;

NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Prefix(
    ConstString p)
    : … { … }

bool NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Match(
    ConstString class_name) { … }

NSDictionary_Additionals::AdditionalFormatterMatching::Full::Full(ConstString n)
    : … { … }

bool NSDictionary_Additionals::AdditionalFormatterMatching::Full::Match(
    ConstString class_name) { … }

NSDictionary_Additionals::AdditionalFormatters<
    CXXFunctionSummaryFormat::Callback> &
NSDictionary_Additionals::GetAdditionalSummaries() { … }

NSDictionary_Additionals::AdditionalFormatters<
    CXXSyntheticChildren::CreateFrontEndCallback> &
NSDictionary_Additionals::GetAdditionalSynthetics() { … }

static CompilerType GetLLDBNSPairType(TargetSP target_sp) { … }

namespace lldb_private {
namespace formatters {
class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };

class NSConstantDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };

class NSCFDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };

class NSDictionary1SyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };

template <typename D32, typename D64>
class GenericNSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };
  
namespace Foundation1100 {
  class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { … };
}
  
namespace Foundation1428 {
  namespace {
    struct DataDescriptor_32 { … };
    
    struct DataDescriptor_64 { … };
  }

  NSDictionaryMSyntheticFrontEnd;
}
  
namespace Foundation1437 {
    static const uint64_t NSDictionaryCapacities[] = …;
    
    static const size_t NSDictionaryNumSizeBuckets = …;

    namespace {
    struct DataDescriptor_32 { … };
    
    struct DataDescriptor_64 { … };
    } // namespace

  NSDictionaryMSyntheticFrontEnd;
  
  template <typename DD>
  uint64_t
  __NSDictionaryMSize_Impl(lldb_private::Process &process,
                           lldb::addr_t valobj_addr, Status &error) { … }
  
  uint64_t
  __NSDictionaryMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
               Status &error) { … }

}
} // namespace formatters
} // namespace lldb_private

template <bool name_entries>
bool lldb_private::formatters::NSDictionarySummaryProvider(
    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { … }

SyntheticChildrenFrontEnd *
lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
    CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) { … }

lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
    NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
    ~NSDictionaryISyntheticFrontEnd() { … }

size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
    GetIndexOfChildWithName(ConstString name) { … }

llvm::Expected<uint32_t> lldb_private::formatters::
    NSDictionaryISyntheticFrontEnd::CalculateNumChildren() { … }

lldb::ChildCacheState
lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() { … }

bool lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
    MightHaveChildren() { … }

lldb::ValueObjectSP
lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex(
    uint32_t idx) { … }

lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
    NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

size_t lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
    GetIndexOfChildWithName(ConstString name) { … }

llvm::Expected<uint32_t> lldb_private::formatters::
    NSCFDictionarySyntheticFrontEnd::CalculateNumChildren() { … }

lldb::ChildCacheState
lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::Update() { … }

bool lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
    MightHaveChildren() { … }

lldb::ValueObjectSP
lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::GetChildAtIndex(
    uint32_t idx) { … }

lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
    NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

size_t lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
    GetIndexOfChildWithName(ConstString name) { … }

llvm::Expected<uint32_t> lldb_private::formatters::
    NSConstantDictionarySyntheticFrontEnd::CalculateNumChildren() { … }

lldb::ChildCacheState
lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::Update() { … }

bool lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
    MightHaveChildren() { … }

lldb::ValueObjectSP lldb_private::formatters::
    NSConstantDictionarySyntheticFrontEnd::GetChildAtIndex(uint32_t idx) { … }

lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
    NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
    GetIndexOfChildWithName(ConstString name) { … }

llvm::Expected<uint32_t> lldb_private::formatters::
    NSDictionary1SyntheticFrontEnd::CalculateNumChildren() { … }

lldb::ChildCacheState
lldb_private::formatters::NSDictionary1SyntheticFrontEnd::Update() { … }

bool lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
    MightHaveChildren() { … }

lldb::ValueObjectSP
lldb_private::formatters::NSDictionary1SyntheticFrontEnd::GetChildAtIndex(
    uint32_t idx) { … }

template <typename D32, typename D64>
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32, D64>::
    GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

template <typename D32, typename D64>
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
    D32, D64>::GenericNSDictionaryMSyntheticFrontEnd::
    ~GenericNSDictionaryMSyntheticFrontEnd() { … }

template <typename D32, typename D64>
size_t lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
    D32, D64>::GetIndexOfChildWithName(ConstString name) { … }

template <typename D32, typename D64>
llvm::Expected<uint32_t>
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
    D32, D64>::CalculateNumChildren() { … }

template <typename D32, typename D64>
lldb::ChildCacheState
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,
                                                                D64>::Update() { … }

template <typename D32, typename D64>
bool
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
    MightHaveChildren() { … }

template <typename D32, typename D64>
lldb::ValueObjectSP
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
    D32, D64>::GetChildAtIndex(uint32_t idx) { … }

lldb_private::formatters::Foundation1100::NSDictionaryMSyntheticFrontEnd::
    NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
    : … { … }

lldb_private::formatters::Foundation1100::
  NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd() { … }

size_t
lldb_private::formatters::Foundation1100::
  NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(ConstString name) { … }

llvm::Expected<uint32_t> lldb_private::formatters::Foundation1100::
    NSDictionaryMSyntheticFrontEnd::CalculateNumChildren() { … }

lldb::ChildCacheState lldb_private::formatters::Foundation1100::
    NSDictionaryMSyntheticFrontEnd::Update() { … }

bool
lldb_private::formatters::Foundation1100::
  NSDictionaryMSyntheticFrontEnd::MightHaveChildren() { … }

lldb::ValueObjectSP
lldb_private::formatters::Foundation1100::
  NSDictionaryMSyntheticFrontEnd::GetChildAtIndex(uint32_t idx) { … }

template bool lldb_private::formatters::NSDictionarySummaryProvider<true>(
    ValueObject &, Stream &, const TypeSummaryOptions &);

template bool lldb_private::formatters::NSDictionarySummaryProvider<false>(
    ValueObject &, Stream &, const TypeSummaryOptions &);
llvm/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp
