//===-- 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"

using namespace lldb;

using namespace lldb_private;

using namespace lldb_private::formatters;

NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Prefix(

    ConstString p)

    : m_prefix(p) {}

bool NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Match(

    ConstString class_name) {

  return class_name.GetStringRef().startswith(m_prefix.GetStringRef());

}

NSDictionary_Additionals::AdditionalFormatterMatching::Full::Full(ConstString n)

    : m_name(n) {}

bool NSDictionary_Additionals::AdditionalFormatterMatching::Full::Match(

    ConstString class_name) {

  return (class_name == m_name);

}

NSDictionary_Additionals::AdditionalFormatters<

    CXXFunctionSummaryFormat::Callback> &

NSDictionary_Additionals::GetAdditionalSummaries() {

  static AdditionalFormatters<CXXFunctionSummaryFormat::Callback> g_map;

  return g_map;

}

NSDictionary_Additionals::AdditionalFormatters<

    CXXSyntheticChildren::CreateFrontEndCallback> &

NSDictionary_Additionals::GetAdditionalSynthetics() {

  static AdditionalFormatters<CXXSyntheticChildren::CreateFrontEndCallback>

      g_map;

  return g_map;

}

static CompilerType GetLLDBNSPairType(TargetSP target_sp) {

  CompilerType compiler_type;

  TypeSystemClangSP scratch_ts_sp =

      ScratchTypeSystemClang::GetForTarget(*target_sp);

  if (!scratch_ts_sp)

    return compiler_type;

  static constexpr llvm::StringLiteral g_lldb_autogen_nspair("__lldb_autogen_nspair");

  compiler_type = scratch_ts_sp->GetTypeForIdentifier<clang::CXXRecordDecl>(g_lldb_autogen_nspair);

  if (!compiler_type) {

    compiler_type = scratch_ts_sp->CreateRecordType(

        nullptr, OptionalClangModuleID(), lldb::eAccessPublic,

        g_lldb_autogen_nspair, clang::TTK_Struct, lldb::eLanguageTypeC);

    if (compiler_type) {

      TypeSystemClang::StartTagDeclarationDefinition(compiler_type);

      CompilerType id_compiler_type =

          scratch_ts_sp->GetBasicType(eBasicTypeObjCID);

      TypeSystemClang::AddFieldToRecordType(

          compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);

      TypeSystemClang::AddFieldToRecordType(

          compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0);

      TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);

    }

  }

  return compiler_type;

}

namespace lldb_private {

namespace formatters {

class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd {

public:

  NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

  ~NSDictionaryISyntheticFrontEnd() override;

  size_t CalculateNumChildren() override;

  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

  bool Update() override;

  bool MightHaveChildren() override;

  size_t GetIndexOfChildWithName(ConstString name) override;

private:

  struct DataDescriptor_32 {

    uint32_t _used : 26;

    uint32_t _szidx : 6;

  };

  struct DataDescriptor_64 {

    uint64_t _used : 58;

    uint32_t _szidx : 6;

  };

  struct DictionaryItemDescriptor {

    lldb::addr_t key_ptr;

    lldb::addr_t val_ptr;

    lldb::ValueObjectSP valobj_sp;

  };

  ExecutionContextRef m_exe_ctx_ref;

  uint8_t m_ptr_size = 8;

  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;

  DataDescriptor_32 *m_data_32 = nullptr;

  DataDescriptor_64 *m_data_64 = nullptr;

  lldb::addr_t m_data_ptr = LLDB_INVALID_ADDRESS;

  CompilerType m_pair_type;

  std::vector<DictionaryItemDescriptor> m_children;

};

class NSConstantDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {

public:

  NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

  size_t CalculateNumChildren() override;

  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

  bool Update() override;

  bool MightHaveChildren() override;

  size_t GetIndexOfChildWithName(ConstString name) override;

private:

  ExecutionContextRef m_exe_ctx_ref;

  CompilerType m_pair_type;

  uint8_t m_ptr_size = 8;

  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;

  unsigned int m_size = 0;

  lldb::addr_t m_keys_ptr = LLDB_INVALID_ADDRESS;

  lldb::addr_t m_objects_ptr = LLDB_INVALID_ADDRESS;

  struct DictionaryItemDescriptor {

    lldb::addr_t key_ptr;

    lldb::addr_t val_ptr;

    lldb::ValueObjectSP valobj_sp;

  };

  std::vector<DictionaryItemDescriptor> m_children;

};

class NSCFDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {

public:

  NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

  size_t CalculateNumChildren() override;

  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

  bool Update() override;

  bool MightHaveChildren() override;

  size_t GetIndexOfChildWithName(ConstString name) override;

private:

  struct DictionaryItemDescriptor {

    lldb::addr_t key_ptr;

    lldb::addr_t val_ptr;

    lldb::ValueObjectSP valobj_sp;

  };

  ExecutionContextRef m_exe_ctx_ref;

  uint8_t m_ptr_size = 8;

  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;

  CFBasicHash m_hashtable;

  CompilerType m_pair_type;

  std::vector<DictionaryItemDescriptor> m_children;

};

class NSDictionary1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {

public:

  NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

  ~NSDictionary1SyntheticFrontEnd() override = default;

  size_t CalculateNumChildren() override;

  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

  bool Update() override;

  bool MightHaveChildren() override;

  size_t GetIndexOfChildWithName(ConstString name) override;

private:

  ValueObjectSP m_pair;

};

template <typename D32, typename D64>

class GenericNSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {

public:

  GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

  ~GenericNSDictionaryMSyntheticFrontEnd() override;

  size_t CalculateNumChildren() override;

  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

  bool Update() override;

  bool MightHaveChildren() override;

  size_t GetIndexOfChildWithName(ConstString name) override;

private:

  struct DictionaryItemDescriptor {

    lldb::addr_t key_ptr;

    lldb::addr_t val_ptr;

    lldb::ValueObjectSP valobj_sp;

  };

  ExecutionContextRef m_exe_ctx_ref;

  uint8_t m_ptr_size = 8;

  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;

  D32 *m_data_32;

  D64 *m_data_64;

  CompilerType m_pair_type;

  std::vector<DictionaryItemDescriptor> m_children;

};

namespace Foundation1100 {

  class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {

  public:

    NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

    ~NSDictionaryMSyntheticFrontEnd() override;

    size_t CalculateNumChildren() override;

    lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;

    bool Update() override;

    bool MightHaveChildren() override;

    size_t GetIndexOfChildWithName(ConstString name) override;

  private:

    struct DataDescriptor_32 {

      uint32_t _used : 26;

      uint32_t _kvo : 1;

      uint32_t _size;

      uint32_t _mutations;

      uint32_t _objs_addr;

      uint32_t _keys_addr;

    };

    struct DataDescriptor_64 {

      uint64_t _used : 58;

      uint32_t _kvo : 1;

      uint64_t _size;

      uint64_t _mutations;

      uint64_t _objs_addr;

      uint64_t _keys_addr;

    };

    struct DictionaryItemDescriptor {

      lldb::addr_t key_ptr;

      lldb::addr_t val_ptr;

      lldb::ValueObjectSP valobj_sp;

    };

    ExecutionContextRef m_exe_ctx_ref;

    uint8_t m_ptr_size = 8;

    lldb::ByteOrder m_order = lldb::eByteOrderInvalid;

    DataDescriptor_32 *m_data_32 = nullptr;

    DataDescriptor_64 *m_data_64 = nullptr;

    CompilerType m_pair_type;

    std::vector<DictionaryItemDescriptor> m_children;

  };

}

namespace Foundation1428 {

  namespace {

    struct DataDescriptor_32 {

      uint32_t _used : 26;

      uint32_t _kvo : 1;

      uint32_t _size;

      uint32_t _buffer;

      uint64_t GetSize() { return _size; }

    };

    struct DataDescriptor_64 {

      uint64_t _used : 58;

      uint32_t _kvo : 1;

      uint64_t _size;

      uint64_t _buffer;

      uint64_t GetSize() { return _size; }

    };

  }

  using NSDictionaryMSyntheticFrontEnd =

    GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;

}

namespace Foundation1437 {

    static const uint64_t NSDictionaryCapacities[] = {

        0, 3, 7, 13, 23, 41, 71, 127, 191, 251, 383, 631, 1087, 1723,

        2803, 4523, 7351, 11959, 19447, 31231, 50683, 81919, 132607,

        214519, 346607, 561109, 907759, 1468927, 2376191, 3845119,

        6221311, 10066421, 16287743, 26354171, 42641881, 68996069,

        111638519, 180634607, 292272623, 472907251

    };

    static const size_t NSDictionaryNumSizeBuckets =

        sizeof(NSDictionaryCapacities) / sizeof(uint64_t);

    namespace {

    struct DataDescriptor_32 {

      uint32_t _buffer;

      uint32_t _muts;

      uint32_t _used : 25;

      uint32_t _kvo : 1;

      uint32_t _szidx : 6;

      uint64_t GetSize() {

        return (_szidx) >= NSDictionaryNumSizeBuckets ?

            0 : NSDictionaryCapacities[_szidx];

      }

    };

    struct DataDescriptor_64 {

      uint64_t _buffer;

      uint32_t _muts;

      uint32_t _used : 25;

      uint32_t _kvo : 1;

      uint32_t _szidx : 6;

      uint64_t GetSize() {

        return (_szidx) >= NSDictionaryNumSizeBuckets ?

            
00
 : NSDictionaryCapacities[_szidx];

      }

    };

    } // namespace

  using NSDictionaryMSyntheticFrontEnd =

    GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;

  template <typename DD>

  uint64_t

  __NSDictionaryMSize_Impl(lldb_private::Process &process,

                           lldb::addr_t valobj_addr, Status &error) {

    const lldb::addr_t start_of_descriptor =

        valobj_addr + process.GetAddressByteSize();

    DD descriptor = DD();

    process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),

                       error);

    if (error.Fail()) {

      return 0;

    }

    return descriptor._used;

  }

Unexecuted instantiation: NSDictionary.cpp:unsigned long long lldb_private::formatters::Foundation1437::__NSDictionaryMSize_Impl<lldb_private::formatters::Foundation1437::(anonymous namespace)::DataDescriptor_32>(lldb_private::Process&, unsigned long long, lldb_private::Status&)

NSDictionary.cpp:unsigned long long lldb_private::formatters::Foundation1437::__NSDictionaryMSize_Impl<lldb_private::formatters::Foundation1437::(anonymous namespace)::DataDescriptor_64>(lldb_private::Process&, unsigned long long, lldb_private::Status&)

Line

Count

Source

379

46

                           lldb::addr_t valobj_addr, Status &error) {

380

46

    const lldb::addr_t start_of_descriptor =

381

46

        valobj_addr + process.GetAddressByteSize();

382

46

    DD descriptor = DD();

383

46

    process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),

384

46

                       error);

385

46

    if (error.Fail()) {

386

0

      return 0;

387

0

    }

388

46

    return descriptor._used;

389

46

  }

  uint64_t

  __NSDictionaryMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,

               Status &error) {

    if (process.GetAddressByteSize() == 4) {

      return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr,

                                                         error);

    } else {

      return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,

                                                         error);

    }

  }

}

} // namespace formatters

} // namespace lldb_private

template <bool name_entries>

bool lldb_private::formatters::NSDictionarySummaryProvider(

    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {

  static constexpr llvm::StringLiteral g_TypeHint("NSDictionary");

  ProcessSP process_sp = valobj.GetProcessSP();

  if (!process_sp)

    return false;

  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);

  if (!runtime)

    return false;

  ObjCLanguageRuntime::ClassDescriptorSP descriptor(

      runtime->GetNonKVOClassDescriptor(valobj));

  if (!descriptor || 
!descriptor->IsValid()173
)

    return false;

  uint32_t ptr_size = process_sp->GetAddressByteSize();

  bool is_64bit = (ptr_size == 8);

  lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);

  if (!valobj_addr)

    return false;

  uint64_t value = 0;

  ConstString class_name(descriptor->GetClassName());

  static const ConstString g_DictionaryI("__NSDictionaryI");

  static const ConstString g_DictionaryM("__NSDictionaryM");

  static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");

  static const ConstString g_DictionaryMImmutable("__NSDictionaryM_Immutable");

  static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");

  static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");

  static const ConstString g_Dictionary0("__NSDictionary0");

  static const ConstString g_DictionaryCF("__CFDictionary");

  static const ConstString g_DictionaryNSCF("__NSCFDictionary");

  static const ConstString g_DictionaryCFRef("CFDictionaryRef");

  static const ConstString g_ConstantDictionary("NSConstantDictionary");

  if (class_name.IsEmpty())

    return false;

  if (class_name == g_DictionaryI || 
class_name == g_DictionaryMImmutable82
) {

    Status error;

    value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

                                                      ptr_size, 0, error);

    if (error.Fail())

      return false;

    value &= (is_64bit ? ~0xFC00000000000000UL : 
~0xFC000000U0
);

  } else 
if (82
class_name == g_ConstantDictionary82
) {

    Status error;

    value = process_sp->ReadUnsignedIntegerFromMemory(

        valobj_addr + 2 * ptr_size, ptr_size, 0, error);

    if (error.Fail())

      return false;

  } else if (class_name == g_DictionaryM || 
class_name == g_DictionaryMLegacy42
 ||

             
class_name == g_DictionaryMFrozen42
) {

    AppleObjCRuntime *apple_runtime =

    llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);

    Status error;

    if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {

      value = Foundation1437::__NSDictionaryMSize(*process_sp, valobj_addr,

                                                  error);

    } else {

      value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

                                                        ptr_size, 0, error);

      value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);

    }

    if (error.Fail())

      return false;

  } else 
if (36
class_name == g_Dictionary136
) {

    value = 1;

  } else if (class_name == g_Dictionary0) {

    value = 0;

  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||

             
class_name == g_DictionaryCFRef0
) {

    ExecutionContext exe_ctx(process_sp);

    CFBasicHash cfbh;

    if (!cfbh.Update(valobj_addr, exe_ctx))

      return false;

    value = cfbh.GetCount();

  } else {

    auto &map(NSDictionary_Additionals::GetAdditionalSummaries());

    for (auto &candidate : map) {

      if (candidate.first && candidate.first->Match(class_name))

        return candidate.second(valobj, stream, options);

    }

    return false;

  }

  llvm::StringRef prefix, suffix;

  if (Language *language = Language::FindPlugin(options.GetLanguage()))

    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);

  stream << prefix;

  stream.Printf("%" PRIu64 " %s%s", value, "key/value pair",

                value == 1 ? 
""12
 : 
"s"160
);

  stream << suffix;

  return true;

}

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

Line

Count

Source

409

18

    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {

410

18

  static constexpr llvm::StringLiteral g_TypeHint("NSDictionary");

411

18

  ProcessSP process_sp = valobj.GetProcessSP();

412

18

  if (!process_sp)

413

0

    return false;

414

415

18

  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);

416

417

18

  if (!runtime)

418

0

    return false;

419

420

18

  ObjCLanguageRuntime::ClassDescriptorSP descriptor(

421

18

      runtime->GetNonKVOClassDescriptor(valobj));

422

423

18

  if (!descriptor || 
!descriptor->IsValid()17
)

424

1

    return false;

425

426

17

  uint32_t ptr_size = process_sp->GetAddressByteSize();

427

17

  bool is_64bit = (ptr_size == 8);

428

429

17

  lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);

430

431

17

  if (!valobj_addr)

432

1

    return false;

433

434

16

  uint64_t value = 0;

435

436

16

  ConstString class_name(descriptor->GetClassName());

437

438

16

  static const ConstString g_DictionaryI("__NSDictionaryI");

439

16

  static const ConstString g_DictionaryM("__NSDictionaryM");

440

16

  static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");

441

16

  static const ConstString g_DictionaryMImmutable("__NSDictionaryM_Immutable");

442

16

  static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");

443

16

  static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");

444

16

  static const ConstString g_Dictionary0("__NSDictionary0");

445

16

  static const ConstString g_DictionaryCF("__CFDictionary");

446

16

  static const ConstString g_DictionaryNSCF("__NSCFDictionary");

447

16

  static const ConstString g_DictionaryCFRef("CFDictionaryRef");

448

16

  static const ConstString g_ConstantDictionary("NSConstantDictionary");

449

450

16

  if (class_name.IsEmpty())

451

0

    return false;

452

453

16

  if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {

454

0

    Status error;

455

0

    value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

456

0

                                                      ptr_size, 0, error);

457

0

    if (error.Fail())

458

0

      return false;

459

460

0

    value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);

461

16

  } else if (class_name == g_ConstantDictionary) {

462

0

    Status error;

463

0

    value = process_sp->ReadUnsignedIntegerFromMemory(

464

0

        valobj_addr + 2 * ptr_size, ptr_size, 0, error);

465

0

    if (error.Fail())

466

0

      return false;

467

16

  } else if (class_name == g_DictionaryM || 
class_name == g_DictionaryMLegacy10
 ||

468

16

             
class_name == g_DictionaryMFrozen10
) {

469

6

    AppleObjCRuntime *apple_runtime =

470

6

    llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);

471

6

    Status error;

472

6

    if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {

473

6

      value = Foundation1437::__NSDictionaryMSize(*process_sp, valobj_addr,

474

6

                                                  error);

475

6

    } else {

476

0

      value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

477

0

                                                        ptr_size, 0, error);

478

0

      value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);

479

0

    }

480

6

    if (error.Fail())

481

0

      return false;

482

10

  } else if (class_name == g_Dictionary1) {

483

0

    value = 1;

484

10

  } else if (class_name == g_Dictionary0) {

485

0

    value = 0;

486

10

  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||

487

10

             
class_name == g_DictionaryCFRef0
) {

488

10

    ExecutionContext exe_ctx(process_sp);

489

10

    CFBasicHash cfbh;

490

10

    if (!cfbh.Update(valobj_addr, exe_ctx))

491

0

      return false;

492

10

    value = cfbh.GetCount();

493

10

  } else {

494

0

    auto &map(NSDictionary_Additionals::GetAdditionalSummaries());

495

0

    for (auto &candidate : map) {

496

0

      if (candidate.first && candidate.first->Match(class_name))

497

0

        return candidate.second(valobj, stream, options);

498

0

    }

499

0

    return false;

500

0

  }

501

502

16

  llvm::StringRef prefix, suffix;

503

16

  if (Language *language = Language::FindPlugin(options.GetLanguage()))

504

16

    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);

505

506

16

  stream << prefix;

507

16

  stream.Printf("%" PRIu64 " %s%s", value, "key/value pair",

508

16

                value == 1 ? 
""0
 : "s");

509

16

  stream << suffix;

510

16

  return true;

511

16

}

bool lldb_private::formatters::NSDictionarySummaryProvider<false>(lldb_private::ValueObject&, lldb_private::Stream&, lldb_private::TypeSummaryOptions const&)

Line

Count

Source

409

158

    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {

410

158

  static constexpr llvm::StringLiteral g_TypeHint("NSDictionary");

411

158

  ProcessSP process_sp = valobj.GetProcessSP();

412

158

  if (!process_sp)

413

0

    return false;

414

415

158

  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);

416

417

158

  if (!runtime)

418

0

    return false;

419

420

158

  ObjCLanguageRuntime::ClassDescriptorSP descriptor(

421

158

      runtime->GetNonKVOClassDescriptor(valobj));

422

423

158

  if (!descriptor || 
!descriptor->IsValid()156
)

424

2

    return false;

425

426

156

  uint32_t ptr_size = process_sp->GetAddressByteSize();

427

156

  bool is_64bit = (ptr_size == 8);

428

429

156

  lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);

430

431

156

  if (!valobj_addr)

432

0

    return false;

433

434

156

  uint64_t value = 0;

435

436

156

  ConstString class_name(descriptor->GetClassName());

437

438

156

  static const ConstString g_DictionaryI("__NSDictionaryI");

439

156

  static const ConstString g_DictionaryM("__NSDictionaryM");

440

156

  static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");

441

156

  static const ConstString g_DictionaryMImmutable("__NSDictionaryM_Immutable");

442

156

  static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");

443

156

  static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");

444

156

  static const ConstString g_Dictionary0("__NSDictionary0");

445

156

  static const ConstString g_DictionaryCF("__CFDictionary");

446

156

  static const ConstString g_DictionaryNSCF("__NSCFDictionary");

447

156

  static const ConstString g_DictionaryCFRef("CFDictionaryRef");

448

156

  static const ConstString g_ConstantDictionary("NSConstantDictionary");

449

450

156

  if (class_name.IsEmpty())

451

0

    return false;

452

453

156

  if (class_name == g_DictionaryI || 
class_name == g_DictionaryMImmutable66
) {

454

90

    Status error;

455

90

    value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

456

90

                                                      ptr_size, 0, error);

457

90

    if (error.Fail())

458

0

      return false;

459

460

90

    value &= (is_64bit ? ~0xFC00000000000000UL : 
~0xFC000000U0
);

461

90

  } else 
if (66
class_name == g_ConstantDictionary66
) {

462

0

    Status error;

463

0

    value = process_sp->ReadUnsignedIntegerFromMemory(

464

0

        valobj_addr + 2 * ptr_size, ptr_size, 0, error);

465

0

    if (error.Fail())

466

0

      return false;

467

66

  } else if (class_name == g_DictionaryM || 
class_name == g_DictionaryMLegacy32
 ||

468

66

             
class_name == g_DictionaryMFrozen32
) {

469

40

    AppleObjCRuntime *apple_runtime =

470

40

    llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);

471

40

    Status error;

472

40

    if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {

473

40

      value = Foundation1437::__NSDictionaryMSize(*process_sp, valobj_addr,

474

40

                                                  error);

475

40

    } else {

476

0

      value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,

477

0

                                                        ptr_size, 0, error);

478

0

      value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);

479

0

    }

480

40

    if (error.Fail())

481

0

      return false;

482

40

  } else 
if (26
class_name == g_Dictionary126
) {

483

4

    value = 1;

484

22

  } else if (class_name == g_Dictionary0) {

485

2

    value = 0;

486

20

  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||

487

20

             
class_name == g_DictionaryCFRef0
) {

488

20

    ExecutionContext exe_ctx(process_sp);

489

20

    CFBasicHash cfbh;

490

20

    if (!cfbh.Update(valobj_addr, exe_ctx))

491

0

      return false;

492

20

    value = cfbh.GetCount();

493

20

  } else {

494

0

    auto &map(NSDictionary_Additionals::GetAdditionalSummaries());

495

0

    for (auto &candidate : map) {

496

0

      if (candidate.first && candidate.first->Match(class_name))

497

0

        return candidate.second(valobj, stream, options);

498

0

    }

499

0

    return false;

500

0

  }

501

502

156

  llvm::StringRef prefix, suffix;

503

156

  if (Language *language = Language::FindPlugin(options.GetLanguage()))

504

156

    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);

505

506

156

  stream << prefix;

507

156

  stream.Printf("%" PRIu64 " %s%s", value, "key/value pair",

508

156

                value == 1 ? 
""12
 : 
"s"144
);

509

156

  stream << suffix;

510

156

  return true;

511

156

}

SyntheticChildrenFrontEnd *

lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(

    CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {

  lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());

  if (!process_sp)

    return nullptr;

  AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(

      ObjCLanguageRuntime::Get(*process_sp));

  if (!runtime)

    return nullptr;

  CompilerType valobj_type(valobj_sp->GetCompilerType());

  Flags flags(valobj_type.GetTypeInfo());

  if (flags.IsClear(eTypeIsPointer)) {

    Status error;

    valobj_sp = valobj_sp->AddressOf(error);

    if (error.Fail() || !valobj_sp)

      return nullptr;

  }

  ObjCLanguageRuntime::ClassDescriptorSP descriptor(

      runtime->GetClassDescriptor(*valobj_sp));

  if (!descriptor || 
!descriptor->IsValid()226
)

    return nullptr;

  ConstString class_name(descriptor->GetClassName());

  static const ConstString g_DictionaryI("__NSDictionaryI");

  static const ConstString g_DictionaryM("__NSDictionaryM");

  static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");

  static const ConstString g_DictionaryImmutable("__NSDictionaryM_Immutable");

  static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");

  static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");

  static const ConstString g_Dictionary0("__NSDictionary0");

  static const ConstString g_DictionaryCF("__CFDictionary");

  static const ConstString g_DictionaryNSCF("__NSCFDictionary");

  static const ConstString g_DictionaryCFRef("CFDictionaryRef");

  static const ConstString g_ConstantDictionary("NSConstantDictionary");

  if (class_name.IsEmpty())

    return nullptr;

  if (class_name == g_DictionaryI) {

    return (new NSDictionaryISyntheticFrontEnd(valobj_sp));

  } else if (class_name == g_ConstantDictionary) {

    return (new NSConstantDictionarySyntheticFrontEnd(valobj_sp));

  } else if (class_name == g_DictionaryM || 
class_name == g_DictionaryMFrozen68
) {

    if (runtime->GetFoundationVersion() >= 1437) {

      return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp));

    } else 
if (0
runtime->GetFoundationVersion() >= 14280
) {

      return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp));

    } else {

      return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));

    }

  } else 
if (58
class_name == g_DictionaryMLegacy58
) {

    return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));

  } else if (class_name == g_Dictionary1) {

    return (new NSDictionary1SyntheticFrontEnd(valobj_sp));

  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||

             
class_name == g_DictionaryCFRef4
) {

    return (new NSCFDictionarySyntheticFrontEnd(valobj_sp));

  } else {

    auto &map(NSDictionary_Additionals::GetAdditionalSynthetics());

    for (auto &candidate : map) {

      if (candidate.first && candidate.first->Match((class_name)))

        return candidate.second(synth, valobj_sp);

    }

  }

  return nullptr;

}

lldb_private::formatters::NSDictionaryISyntheticFrontEnd::

    NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)

    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_type() {}

lldb_private::formatters::NSDictionaryISyntheticFrontEnd::

    ~NSDictionaryISyntheticFrontEnd() {

  delete m_data_32;

  m_data_32 = nullptr;

  delete m_data_64;

  m_data_64 = nullptr;

}

size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::

    GetIndexOfChildWithName(ConstString name) {

  const char *item_name = name.GetCString();

  uint32_t idx = ExtractIndexFromString(item_name);

  if (idx < UINT32_MAX && idx >= CalculateNumChildren())

    return UINT32_MAX;

  return idx;

}

size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::

    CalculateNumChildren() {

  if (!m_data_32 && !m_data_64)

    return 0;

  return (m_data_32 ? 
m_data_32->_used0
 : m_data_64->_used);

}

bool lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() {

  m_children.clear();

  delete m_data_32;

  m_data_32 = nullptr;

  delete m_data_64;

  m_data_64 = nullptr;

  m_ptr_size = 0;

  ValueObjectSP valobj_sp = m_backend.GetSP();

  if (!valobj_sp)

    return false;

  m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();

  Status error;

  error.Clear();

  lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());

  if (!process_sp)

    return false;

  m_ptr_size = process_sp->GetAddressByteSize();

  m_order = process_sp->GetByteOrder();

  uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;

  if (m_ptr_size == 4) {

    m_data_32 = new DataDescriptor_32();

    process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),

                           error);

  } else {

    m_data_64 = new DataDescriptor_64();

    process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),

                           error);

  }

  if (error.Fail())

    return false;

  m_data_ptr = data_location + m_ptr_size;

  return false;

}

bool lldb_private::formatters::NSDictionaryISyntheticFrontEnd::

    MightHaveChildren() {

  return true;

}

lldb::ValueObjectSP

lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex(

    size_t idx) {

  uint32_t num_children = CalculateNumChildren();

  if (idx >= num_children)

    return lldb::ValueObjectSP();

  if (m_children.empty()) {

    // do the scan phase

    lldb::addr_t key_at_idx = 0, val_at_idx = 0;

    uint32_t tries = 0;

    uint32_t test_idx = 0;

    while (tries < num_children) {

      key_at_idx = m_data_ptr + (2 * test_idx * m_ptr_size);

      val_at_idx = key_at_idx + m_ptr_size;

      ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();

      if (!process_sp)

        return lldb::ValueObjectSP();

      Status error;

      key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);

      if (error.Fail())

        return lldb::ValueObjectSP();

      val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);

      if (error.Fail())

        return lldb::ValueObjectSP();

      test_idx++;

      if (!key_at_idx || 
!val_at_idx70
)

        continue;

      tries++;

      DictionaryItemDescriptor descriptor = {key_at_idx, val_at_idx,

                                             lldb::ValueObjectSP()};

      m_children.push_back(descriptor);

    }

  }

  if (idx >= m_children.size()) // should never happen

    return lldb::ValueObjectSP();

  DictionaryItemDescriptor &dict_item = m_children[idx];

  if (!dict_item.valobj_sp) {

    if (!m_pair_type.IsValid()) {

      TargetSP target_sp(m_backend.GetTargetSP());

      if (!target_sp)

        return ValueObjectSP();

      m_pair_type = GetLLDBNSPairType(target_sp);

    }

    if (!m_pair_type.IsValid())

      return ValueObjectSP();

    WritableDataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));

    if (m_ptr_size == 8) {

      uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();

      *data_ptr = dict_item.key_ptr;

      *(data_ptr + 1) = dict_item.val_ptr;

    } else {

      uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();

      *data_ptr = dict_item.key_ptr;

      *(data_ptr + 1) = dict_item.val_ptr;

    }

    StreamString idx_name;

    idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);

    DataExtractor data(buffer_sp, m_order, m_ptr_size);

    dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,

                                                    m_exe_ctx_ref, m_pair_type);

  }

  return dict_item.valobj_sp;

}

lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::

    NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)

    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_hashtable(),

      m_pair_type() {}

size_t lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::

    GetIndexOfChildWithName(ConstString name) {

  const char *item_name = name.GetCString();

  const uint32_t idx = ExtractIndexFromString(item_name);

  if (idx < UINT32_MAX && idx >= CalculateNumChildren())

    return UINT32_MAX;

  return idx;

}

size_t lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::

    CalculateNumChildren() {

  if (!m_hashtable.IsValid())

    return 0;

  return m_hashtable.GetCount();

}

bool lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::Update() {

  m_children.clear();

  ValueObjectSP valobj_sp = m_backend.GetSP();

  m_ptr_size = 0;

  if (!valobj_sp)

    return false;

  m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();

  lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());

  if (!process_sp)

    return false;

  m_ptr_size = process_sp->GetAddressByteSize();

  m_order = process_sp->GetByteOrder();

  return m_hashtable.Update(valobj_sp->GetValueAsUnsigned(0), m_exe_ctx_ref);

}

bool lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::

    MightHaveChildren() {

  return true;

}

lldb::ValueObjectSP

lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::GetChildAtIndex(

    size_t idx) {

  lldb::addr_t m_keys_ptr = m_hashtable.GetKeyPointer();

  lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();

  const uint32_t num_children = CalculateNumChildren();

  if (idx >= num_children)

    return lldb::ValueObjectSP();