[lldb/Dataformatter] Add support for CoreFoundation Dictionaries and Sets

[mib]

Summary

[lldb/Dataformatter] Add support for CoreFoundation Dictionaries and Sets

This patch improves data formatting for CoreFoundation containers:
CFDictionary and CFSet.

These data formatters make the containers and their children appear in Xcode's
variables view (and on the command line) without having to expand the
data structure.

Previous implementation (D48450) only supported showing the container's element count.

(lldb) frame var dict
(__NSCFDictionary *) dict = 0x00000001004062b0 2 key/value pairs

(lldb) frame var set
(__NSCFSet *) set = 0x0000000100406330 2 elements

Now the variable can be dereferenced to dispaly the container's elements:

(lldb) frame var *dict
(__NSCFDictionary) *dict = {
  [0] = {
    key = 0x0000000100004050 @"123"
    value = 0x0000000100004090 @"456"
  }
  [1] = {
    key = 0x0000000100004030 @"abc"
    value = 0x0000000100004070 @"def"
  }
}

(lldb) frame var *set
(__NSCFSet) *set = {
  [0] = 0x0000000100004050 @"123"
  [1] = 0x0000000100004030 @"abc"
}

rdar://39882287

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Reformat patch.

[davide]

Thanks for taking care of this. It's a lot of work. First round of comments.

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

13

Why do you need this? Can't you just use the default destructor?

19–20

I'm under the impression the second return is never hit.

24–25

Can this ever happen? What if addr is 0 instead?

29–30

Thanks for doing this, as it will work on remote devices. We really need to check the test passes on arm64 before committing.

36–72

These two pieces of code, m_ptr_size == 4 and m_ptr_size == 8 are surprisingly similar. I'm really worried we might have a bug in one of them and miss the other. Is there anything we can do to share the code? [e.g. templatize].

140–141

This could be an lldb_assert or unreachable. We really shouldn't be here if ptrsize != 8 or ptrsize != 4, unless there's an egregious bug.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

101

Why?

144

Again, why?

177–187

Maybe a reference to the foundation header where these are defined, if public.

[mib]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

36–72

Indeed, they're very similar and I already tried using templates (and SFINAE) to make it more generic, however I couldn't achieve that.

Since the remote architecture might be different from lldb's, we can't use macros to generate the underlying struct with the right size. So, I decided to template the structure used by CF, and have one of each architecture as a class attribute (look at CFBasicHash.h:114).

Basically it's a tradeoff I chose voluntarily: I preferred having the CFBasicHash class handle the architecture to only expose one CFBasicHash object in the CFDictionary and CFSet data-formatter, rather than having two CFBasicHash objects templated for each ptr_size and have all the logic duplicated for each different architecture AND each data formatters.

If you can see a better way to do it, please let me know :)

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

177–187

It is not in a public header, that's why I copied the explanation.

[mib]

Address Davide's comments.

[labath]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

36–72

template<typename T> updateFor(std::unique_ptr<__CFBasicHash<T>> &m_ht, ...)

if (m_ptr_size == 4)
  updateFor<uint32_t>(m_ht_4, ...);
else if (m_ptr_size == 8)
  updateFor<uint64_t>(m_ht_8, ...)

?

Or the entire class could be a template, inheriting from a common (non-templatized) interface...

103–108

No manual memory management, please.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

177–187

Are these actually used anywhere?

[mib]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

36–72

I didn't think about that --' ... Thanks for the suggestion ^^

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

177–187

This is a left-over used in the multi variant implement that I'm working on ...

[mib]

Address Pavel's comments.

[davide]

This is almost ready. After we're done with this round of cosmetics, I'll take another look a the algorithm and sign off.

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

18–19

else after return

34–38

else after return. no need for {}

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

753–776

Can you add a comment explaining what this loop does?

lldb/source/Plugins/Language/ObjC/NSSet.cpp

653

lldbassert. Also no need for the second part of the comment.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSContainer.py

23

stray line

[shafik]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

8

Use in class member initializers please then you can use =default for the constructor this is more idiomatic modern C++

lldb/source/Plugins/Language/ObjC/CFBasicHash.h

64

uint32_t m_ptr_size = UINT32_MAX;

65

lldb::ByteOrder m_byte_order = eByteOrderInvalid;

67

Address m_address = LLDB_INVALID_ADDRESS;

74

These bool should have default values?

I don't see them initialized.

[shafik]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

49

Shouldn't we check that m_ht is actually managing an object before attempting to access it's value?

50

These sizeof calls feel like the should just be consolidated into the initialization of size.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

698

const

738

const

lldb/source/Plugins/Language/ObjC/NSSet.cpp

601

const if a value is not supposed to change make it const always. This prevents bugs where a "const" is modified by mistake.

647

reinterpret_cast and static_cast respectively. Same below.

[mib]

Address Davide's & Shafik's comments.

[mib]

Fix typo.

[davide]

This looks fine to me but please give Pavel another chance to look before committing.

[mib]

In D78396#1993286, @davide wrote:

This looks fine to me but please give Pavel another chance to look before committing.

Will wait for @labath approval :) !

[labath]

I don't have a vested interested here (the main reason I looked at this was the template discussion), but I have made a cursory pass over the patch. I didn't check the high level functionality, but it seems like the implementation details can be improved upon.

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

46

I am not sure, but I think this still may technically be undefined behavior if m_ht is null even though the application of sizeof means the dereference will not normally take place.

48–63

Why don't you just pass m_ht.get() to ReadMemory ?

72–83

ReadMemory(ptr_offset, m_ht->pointers, ...) ?

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

692–693

= default? Maybe even implicitly default by not providing a destructor?

lldb/source/Plugins/Language/ObjC/NSSet.cpp

664–665

You've cargo-culted this code, but you've changed DataBufferSP to a plain DataBuffer. If the created valueobject continues to reference this data (I haven't checked, but I think it does), this will be a dangling reference.

[mib]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

48–63

IIUC, ReadMemory will read memory matching the inferior endianness. That's why, I'm using a DataExtractor, to translate, the copied bytes to the host endianness.

72–83

Same answer.

[mib]

Address Pavel's comments:

• Fix eventual UB by using the struct type in sizeof instead of dereferencing the pointer.
• Remove empty destructors.
• Fix dangling reference.

[labath]

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

48–63

Well, I am glad that you are thinking about non-native endianness, but I am afraid things just don't work that way. There's no way an API like CopyData(void *, size_t) can automatically fix endianness problems. Why? Because the fix depends on the structure of the data.

Imagine this sequence of bytes: 00 01 02 03 04 05 06 07. If this sequence really represents a sequence of (little-endian) bytes (uint8_ts), then the corresponding "big-endian" sequence would be identical. If, however, it represents 2-byte words (uint16_t), then the big-endian representation would be 01 00 03 02 05 04 07 06. For 4-byte words, it would be 03 02 01 00 07 06 05 04, etc.

In short, you need to know the structure of the data to translate endiannes, and CopyData does not know that. Indeed, if you look at the implementation of that function you'll see that it just does a memcpy.

My suggestion for reading directly into the object was based on the assumption that are fine with things working only if everything is of the same endianness. I wouldn't have allowed that in more cross-platform code, but I didn't feel like policing all corners of lldb.

However, if you do want to make this endian-correct (which I do encourage), then you have a couple of options:

• ditch the structs and use data extractor functions to read (GetU32, GetAddress, etc) the individual fields -- these know the size of the object they are accessing, and can adjust endianness appropriately
• compare host and target endianness and call llvm::sys::swapByteOrder on the individual fields if they differ
• use llvm's packed_endian_specific_integral instead of native types in the struct definitions. This would require passing the endiannes as a template parameter and then dispatching to the appropriate struct based on the runtime value similar to how you've already done for byte sizes.

Each of these options has its drawbacks, but I've seen them all places throughout llvm. In this particular case, I have a feeling the simplest option would be to go the DataExtractor route...

[mib]

After playing with llvm::sys::swapByteOrder and the DataExtractor getters (GetU8, GetU16, GetU32 ....), it looks like neither of these supports bitfields.

Since the CFBasicHash struct relies heavily on bitfields, it won't support mixed endianness.

I changed the patch so if the host and the target have different byte orders, lldb will abort the data formatting.
I also removed all the DataBuffer and DataExtractor logic since it's not needed anymore.

[labath]

That seems acceptable (though definitely not ideal), given that this is objc code, and probably no big endian machine will ever be running or debugging objc code...

lldb/source/Plugins/Language/ObjC/CFBasicHash.h

+//===-- CFBasicHash.h -------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_CFBASICHASH_H
+#define LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_CFBASICHASH_H
+
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+namespace lldb_private {
+
+class CFBasicHash {
+public:
+  enum class HashType { set = 0, dict };
+
+  CFBasicHash();
+  ~CFBasicHash();
+
+  bool Update(lldb::addr_t addr, ExecutionContextRef exe_ctx_rf);
+
+  bool IsValid() const;
+
+  bool IsMutable() const { return m_mutable; };
+  bool IsMultiVariant() const { return m_multi; }
+  HashType GetType() const { return m_type; }
+
+  size_t GetCount() const;
+  lldb::addr_t GetKeyPointer() const;
+  lldb::addr_t GetValuePointer() const;
+  
+private:
+  template <typename T> struct __CFBasicHash {
+    struct RuntimeBase {
+      T cfisa;
+      T cfinfoa;
+    } base;
+
+    struct Bits {
+      uint16_t __reserved0;
+      uint16_t __reserved1 : 2;
+      uint16_t keys_offset : 1;
+      uint16_t counts_offset : 2;
+      uint16_t counts_width : 2;
+      uint16_t __reserved2 : 9;
+      uint32_t used_buckets;        // number of used buckets
+      uint64_t deleted : 16;        // number of elements deleted
+      uint64_t num_buckets_idx : 8; // index to number of buckets
+      uint64_t __reserved3 : 40;
+      uint64_t __reserved4;
+    } bits;
+
+    T pointers[3];
+  };
+  template <typename T> bool UpdateFor(std::unique_ptr<__CFBasicHash<T>> &m_ht);
+  
+  size_t GetPointerCount() const;
+
+private:
+  uint32_t m_ptr_size;
+  lldb::ByteOrder m_byte_order;
+
+  Address m_address;
+
+  std::unique_ptr<__CFBasicHash<uint32_t>> m_ht_32;
+  std::unique_ptr<__CFBasicHash<uint64_t>> m_ht_64;
+
+  ExecutionContextRef m_exe_ctx_ref;
+
+  bool m_mutable;
+  bool m_multi;
+  HashType m_type;
+};
+
+}; // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_CFBASICHASH_H

lldb/source/Plugins/Language/ObjC/CFBasicHash.cpp

+#include "CFBasicHash.h"
+
+#include "lldb/Utility/DataBufferHeap.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+CFBasicHash::CFBasicHash()
+    : m_ptr_size(UINT32_MAX), m_byte_order(eByteOrderInvalid),
+      m_address(LLDB_INVALID_ADDRESS) {}
+
+CFBasicHash::~CFBasicHash() { }
+
+bool CFBasicHash::IsValid() const {
+  if (m_address != LLDB_INVALID_ADDRESS) {
+    if (m_ptr_size == 4 && m_ht_32)
+      return true;
+    else if (m_ptr_size == 8 && m_ht_64)
+      return true;
+  }
+  return false;
+}
+
+bool CFBasicHash::Update(addr_t addr, ExecutionContextRef exe_ctx_rf) {
+  if (addr == LLDB_INVALID_ADDRESS || !addr)
+    return false;
+
+  m_address = addr;
+  m_exe_ctx_ref = exe_ctx_rf;
+  m_ptr_size =
+      m_exe_ctx_ref.GetTargetSP()->GetArchitecture().GetAddressByteSize();
+  m_byte_order = m_exe_ctx_ref.GetTargetSP()->GetArchitecture().GetByteOrder();
+
+  if (m_ptr_size == 4) {
+    return UpdateFor(m_ht_32);
+  } else if (m_ptr_size == 8) {
+    return UpdateFor(m_ht_64);
+  }
+  
+  llvm_unreachable("Unsupported architecture. Only 32bits and 64bits supported.");
+}
+
+template<typename T>
+bool CFBasicHash::UpdateFor(std::unique_ptr<__CFBasicHash<T>> &m_ht) {
+  Status error;
+  Target* target = m_exe_ctx_ref.GetTargetSP().get();
+  addr_t addr = m_address.GetLoadAddress(target);
+  size_t size = 0;
+  size += sizeof(m_ht->base);
+  size += sizeof(m_ht->bits);
+
+  DataBufferHeap buffer(size, 0);
+  m_exe_ctx_ref.GetProcessSP()->ReadMemory(addr,
+                                           buffer.GetBytes(),size, error);
+  if (error.Fail())
+    return false;
+
+  DataExtractor data_extractor = DataExtractor(
+      buffer.GetBytes(), buffer.GetByteSize(), m_byte_order, m_ptr_size);
+
+  m_ht = std::make_unique<__CFBasicHash<T>>();
+  size_t copied = data_extractor.CopyData(0, size, m_ht.get());
+
+  if (copied != size) {
+    m_ht = nullptr;
+    return false;
+  }
+
+  m_mutable = !(m_ht->base.cfinfoa & (1 << 6));
+  m_multi = m_ht->bits.counts_offset;
+  m_type = static_cast<HashType>(m_ht->bits.keys_offset);
+  addr_t ptr_offset = addr + size;
+  size_t ptr_count = GetPointerCount();
+  size = ptr_count * sizeof(T);
+  buffer = DataBufferHeap(size, 0);
+  m_exe_ctx_ref.GetProcessSP()->ReadMemory(ptr_offset, buffer.GetBytes(),
+                                           size, error);
+
+  if (error.Fail()) {
+    m_ht = nullptr;
+    return false;
+  }
+
+  data_extractor = DataExtractor(buffer.GetBytes(), buffer.GetByteSize(),
+                                 m_byte_order, m_ptr_size);
+
+  copied = data_extractor.CopyData(0, size, m_ht->pointers);
+
+  if (copied != size) {
+    m_ht = nullptr;
+    return false;
+  }
+
+  return true;
+}
+
+size_t CFBasicHash::GetCount() const {
+  if (!IsValid())
+    return 0;
+
+  if (!m_multi)
+    return (m_ptr_size == 4) ? m_ht_32->bits.used_buckets
+                             : m_ht_64->bits.used_buckets;
+
+  //  FIXME: Add support for multi
+  return 0;
+}
+
+size_t CFBasicHash::GetPointerCount() const {
+  if (!IsValid())
+    return 0;
+
+  if (m_multi)
+    return 3; // Bits::counts_offset;
+  return (m_type == HashType::dict) + 1;
+}
+
+addr_t CFBasicHash::GetKeyPointer() const {
+  if (!IsValid())
+    return LLDB_INVALID_ADDRESS;
+
+  if (m_ptr_size == 4)
+    return m_ht_32->pointers[m_ht_32->bits.keys_offset];
+
+  return m_ht_64->pointers[m_ht_64->bits.keys_offset];
+}
+
+addr_t CFBasicHash::GetValuePointer() const {
+  if (!IsValid())
+    return LLDB_INVALID_ADDRESS;
+
+  if (m_ptr_size == 4)
+    return m_ht_32->pointers[0];
+
+  return m_ht_64->pointers[0];
+}

lldb/source/Plugins/Language/ObjC/CMakeLists.txt

 set(EXTRA_CXXFLAGS "")
 
 if (CXX_SUPPORTS_NO_GNU_ANONYMOUS_STRUCT)
   set(EXTRA_CXXFLAGS ${EXTRA_CXXFLAGS} -Wno-gnu-anonymous-struct)
 endif ()
 
 if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES)
   set(EXTRA_CXXFLAGS ${EXTRA_CXXFLAGS} -Wno-nested-anon-types)
 endif ()
 
 add_lldb_library(lldbPluginObjCLanguage PLUGIN
   ObjCLanguage.cpp
   CF.cpp
+  CFBasicHash.cpp
   Cocoa.cpp
   CoreMedia.cpp
   NSArray.cpp
   NSDictionary.cpp
   NSError.cpp
   NSException.cpp
   NSIndexPath.cpp
   NSSet.cpp

lldb/source/Plugins/Language/ObjC/NSDictionary.h

-//===-- NSDictionary.h ---------------------------------------------------*- C++
-//-*-===//
+//===-- NSDictionary.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_NSDICTIONARY_H

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

 //===-- 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"
if (!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;
private:
   lldb::ByteOrder m_order;
   DataDescriptor_32 *m_data_32;
   DataDescriptor_64 *m_data_64;
   lldb::addr_t m_data_ptr;
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
 
+class NSCFDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+  ~NSCFDictionarySyntheticFrontEnd() 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;
+  lldb::ByteOrder m_order;
+
+  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;
 };
bool lldb_private::formatters::NSDictionarySummaryProvider(
 
   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_Dictionary1("__NSSingleEntryDictionaryI");
   static const ConstString g_Dictionary0("__NSDictionary0");
   static const ConstString g_DictionaryCF("__NSCFDictionary");
+  static const ConstString g_DictionaryCFRef("CFDictionaryRef");
 
   if (class_name.IsEmpty())
     return false;
 
   if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {
     Status error;
     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
                                                       ptr_size, 0, error);
     if (error.Fail())
       return false;
     value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
-  } else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy ||
-             class_name == g_DictionaryCF) {
+  } else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy) {
     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 (class_name == g_Dictionary1) {
     value = 1;
   } else if (class_name == g_Dictionary0) {
     value = 0;
-  }
-  else {
+  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryCFRef) {
+    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;
   }
 
lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
   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_DictionaryMLegacy("__NSDictionaryM_Legacy");
   static const ConstString g_Dictionary0("__NSDictionary0");
+  static const ConstString g_DictionaryCF("__NSCFDictionary");
+  static const ConstString g_DictionaryCFRef("CFDictionaryRef");
 
   if (class_name.IsEmpty())
     return nullptr;
 
   if (class_name == g_DictionaryI) {
     return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_DictionaryM) {
     if (runtime->GetFoundationVersion() >= 1437) {
       return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     } else if (runtime->GetFoundationVersion() >= 1428) {
       return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     } else {
       return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     }
   } else if (class_name == g_DictionaryMLegacy) {
       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_DictionaryCFRef) {
+    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);
     }
   }
 
if (!dict_item.valobj_sp) {
     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_ptr_size(8),
+      m_order(lldb::eByteOrderInvalid), m_hashtable(), m_pair_type() {}
+
+lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
+    ~NSCFDictionarySyntheticFrontEnd() {}
+
+size_t lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
+    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::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();
+
+  uint32_t num_children = CalculateNumChildren();
+
+  if (idx >= num_children)
+    return lldb::ValueObjectSP();
+
+  if (m_children.empty()) {
+    ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+    if (!process_sp)
+      return lldb::ValueObjectSP();
+
+    Status error;
+    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_keys_ptr + (test_idx * m_ptr_size);
+      val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
+
+      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_idx)
+        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();
+
+    DataBufferSP 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::NSDictionary1SyntheticFrontEnd::
     NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
 
 size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
     GetIndexOfChildWithName(ConstString name) {
   static const ConstString g_zero("[0]");
   return name == g_zero ? 0 : UINT32_MAX;
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
     ~GenericNSDictionaryMSyntheticFrontEnd() {
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
   m_data_64 = nullptr;
 }
 
 template <typename D32, typename D64>
-size_t
-lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::    GetIndexOfChildWithName(ConstString name) {
+size_t lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
+    D32, D64>::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;
 }
 
 template <typename D32, typename D64>
process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
                            error);
   } else {
     m_data_64 = new D64();
     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
                            error);
   }
   if (error.Fail())
     return false;
-  return false;
+  return true;
 }
 
 template <typename D32, typename D64>
 bool
 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
     MightHaveChildren() {
   return true;
 }
 
 template <typename D32, typename D64>
 lldb::ValueObjectSP
-lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
-    GetChildAtIndex(
-    size_t idx) {
+lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<
+    D32, D64>::GetChildAtIndex(size_t idx) {
   lldb::addr_t m_keys_ptr;
   lldb::addr_t m_values_ptr;
   if (m_data_32) {
     uint32_t size = m_data_32->GetSize();
     m_keys_ptr = m_data_32->_buffer;
     m_values_ptr = m_data_32->_buffer + (m_ptr_size * size);
   } else {
     uint32_t size = m_data_64->GetSize();
if (!dict_item.valobj_sp) {
     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::Foundation1100::
   NSDictionaryMSyntheticFrontEnd::
     NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
       m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
       m_pair_type() {}
 
 lldb_private::formatters::Foundation1100::

lldb/source/Plugins/Language/ObjC/NSSet.cpp

 //===-- NSSet.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 "NSSet.h"
+#include "CFBasicHash.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/Target.h"
private:
   ExecutionContextRef m_exe_ctx_ref;
   uint8_t m_ptr_size;
   DataDescriptor_32 *m_data_32;
   DataDescriptor_64 *m_data_64;
   lldb::addr_t m_data_ptr;
   std::vector<SetItemDescriptor> m_children;
 };
 
+class NSCFSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  NSCFSetSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+  ~NSCFSetSyntheticFrontEnd() 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 SetItemDescriptor {
+    lldb::addr_t item_ptr;
+    lldb::ValueObjectSP valobj_sp;
+  };
+
+  ExecutionContextRef m_exe_ctx_ref;
+  uint8_t m_ptr_size;
+  lldb::ByteOrder m_order;
+
+  CFBasicHash m_hashtable;
+
+  CompilerType m_pair_type;
+  std::vector<SetItemDescriptor> m_children;
+};
+
 template <typename D32, typename D64>
 class GenericNSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   GenericNSSetMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   ~GenericNSSetMSyntheticFrontEnd() override;
 
   size_t CalculateNumChildren() override;
bool lldb_private::formatters::NSSetSummaryProvider(
 
   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
 
   if (!valobj_addr)
     return false;
 
   uint64_t value = 0;
 
-  ConstString class_name_cs = descriptor->GetClassName();
-  const char *class_name = class_name_cs.GetCString();
+  ConstString class_name(descriptor->GetClassName());
 
-  if (!class_name || !*class_name)
+  static const ConstString g_SetI("__NSSetI");
+  static const ConstString g_OrderedSetI("__NSOrderedSetI");
+  static const ConstString g_SetM("__NSSetM");
+  static const ConstString g_SetCF("__NSCFSet");
+
+  if (class_name.IsEmpty())
     return false;
 
-  if (!strcmp(class_name, "__NSSetI") ||
-      !strcmp(class_name, "__NSOrderedSetI")) {
+  if (class_name == g_SetI || class_name == g_OrderedSetI) {
     Status error;
     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
                                                       ptr_size, 0, error);
     if (error.Fail())
       return false;
     value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
-  } else if (!strcmp(class_name, "__NSSetM")) {
+  } else if (class_name == g_SetM) {
     AppleObjCRuntime *apple_runtime =
         llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
     Status error;
     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
       value = Foundation1437::__NSSetMSize(*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 (class_name == g_SetCF) {
+    ExecutionContext exe_ctx(process_sp);
+    CFBasicHash cfbh;
+    if (!cfbh.Update(valobj_addr, exe_ctx))
+      return false;
+    value = cfbh.GetCount();
   } else {
     auto &map(NSSet_Additionals::GetAdditionalSummaries());
-    auto iter = map.find(class_name_cs), end = map.end();
+    auto iter = map.find(class_name), end = map.end();
     if (iter != end)
       return iter->second(valobj, stream, options);
     else
       return false;
   }
 
   std::string prefix, suffix;
   if (Language *language = Language::FindPlugin(options.GetLanguage())) {
lldb_private::formatters::NSSetSyntheticFrontEndCreator(
   }
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(*valobj_sp));
 
   if (!descriptor || !descriptor->IsValid())
     return nullptr;
 
-  ConstString class_name_cs = descriptor->GetClassName();
-  const char *class_name = class_name_cs.GetCString();
+  ConstString class_name = descriptor->GetClassName();
 
-  if (!class_name || !*class_name)
+  static const ConstString g_SetI("__NSSetI");
+  static const ConstString g_OrderedSetI("__NSOrderedSetI");
+  static const ConstString g_SetM("__NSSetM");
+  static const ConstString g_SetCF("__NSCFSet");
+
+  if (class_name.IsEmpty())
     return nullptr;
 
-  if (!strcmp(class_name, "__NSSetI") ||
-      !strcmp(class_name, "__NSOrderedSetI")) {
+  if (class_name == g_SetI || class_name == g_OrderedSetI) {
     return (new NSSetISyntheticFrontEnd(valobj_sp));
-  } else if (!strcmp(class_name, "__NSSetM")) {
+  } else if (class_name == g_SetM) {
     AppleObjCRuntime *apple_runtime =
         llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
     if (apple_runtime) {
       if (apple_runtime->GetFoundationVersion() >= 1437)
         return (new Foundation1437::NSSetMSyntheticFrontEnd(valobj_sp));
       else if (apple_runtime->GetFoundationVersion() >= 1428)
         return (new Foundation1428::NSSetMSyntheticFrontEnd(valobj_sp));
       else
         return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
     } else {
       return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
     }
+  } else if (class_name == g_SetCF) {
+    return (new NSCFSetSyntheticFrontEnd(valobj_sp));
   } else {
     auto &map(NSSet_Additionals::GetAdditionalSynthetics());
-    auto iter = map.find(class_name_cs), end = map.end();
+    auto iter = map.find(class_name), end = map.end();
     if (iter != end)
       return iter->second(synth, valobj_sp);
     return nullptr;
   }
 }
 
 lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
if (!set_item.valobj_sp) {
     set_item.valobj_sp = CreateValueObjectFromData(
         idx_name.GetString(), data, m_exe_ctx_ref,
         m_backend.GetCompilerType().GetBasicTypeFromAST(
             lldb::eBasicTypeObjCID));
   }
   return set_item.valobj_sp;
 }
 
+lldb_private::formatters::NSCFSetSyntheticFrontEnd::NSCFSetSyntheticFrontEnd(
+    lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
+      m_order(lldb::eByteOrderInvalid), m_hashtable(), m_pair_type() {}
+
+lldb_private::formatters::NSCFSetSyntheticFrontEnd::
+    ~NSCFSetSyntheticFrontEnd() {}
+
+size_t
+lldb_private::formatters::NSCFSetSyntheticFrontEnd::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::NSCFSetSyntheticFrontEnd::CalculateNumChildren() {
+  if (!m_hashtable.IsValid())
+    return 0;
+  return m_hashtable.GetCount();
+}
+
+bool lldb_private::formatters::NSCFSetSyntheticFrontEnd::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::NSCFSetSyntheticFrontEnd::MightHaveChildren() {
+  return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSCFSetSyntheticFrontEnd::GetChildAtIndex(
+    size_t idx) {
+  lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();
+
+  uint32_t num_children = CalculateNumChildren();
+
+  if (idx >= num_children)
+    return lldb::ValueObjectSP();
+
+  if (m_children.empty()) {
+    ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+    if (!process_sp)
+      return lldb::ValueObjectSP();
+
+    Status error;
+    lldb::addr_t val_at_idx = 0;
+
+    uint32_t tries = 0;
+    uint32_t test_idx = 0;
+
+    while (tries < num_children) {
+      val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
+
+      val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
+      if (error.Fail())
+        return lldb::ValueObjectSP();
+
+      test_idx++;
+
+      if (!val_at_idx)
+        continue;
+      tries++;
+
+      SetItemDescriptor descriptor = {val_at_idx, lldb::ValueObjectSP()};
+
+      m_children.push_back(descriptor);
+    }
+  }
+
+  if (idx >= m_children.size()) // should never happen
+    return lldb::ValueObjectSP();
+
+  SetItemDescriptor &set_item = m_children[idx];
+  if (!set_item.valobj_sp) {
+    auto ptr_size = m_ptr_size;
+    DataBufferHeap buffer(ptr_size, 0);
+    switch (ptr_size) {
+    case 0: // architecture has no clue?? - fail
+      return lldb::ValueObjectSP();
+    case 4:
+      *((uint32_t *)buffer.GetBytes()) = (uint32_t)set_item.item_ptr;
+      break;
+    case 8:
+      *((uint64_t *)buffer.GetBytes()) = (uint64_t)set_item.item_ptr;
+      break;
+    default:
+      assert(false && "pointer size is not 4 nor 8 - get out of here ASAP");
+    }
+    StreamString idx_name;
+    idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
+
+    DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(), m_order,
+                       m_ptr_size);
+
+    set_item.valobj_sp = CreateValueObjectFromData(
+        idx_name.GetString(), data, m_exe_ctx_ref,
+        m_backend.GetCompilerType().GetBasicTypeFromAST(
+            lldb::eBasicTypeObjCID));
+  }
+  return set_item.valobj_sp;
+}
+
 template <typename D32, typename D64>
 lldb_private::formatters::
   GenericNSSetMSyntheticFrontEnd<D32, D64>::GenericNSSetMSyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
       m_data_32(nullptr), m_data_64(nullptr) {
   if (valobj_sp)
     Update();

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
                   "__NSSetI synthetic children", ConstString("__NSSetI"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
                   "__NSSetM synthetic children", ConstString("__NSSetM"),
                   ScriptedSyntheticChildren::Flags());
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+                  "__NSCFSet synthetic children", ConstString("__NSCFSet"),
+                  ScriptedSyntheticChildren::Flags());
+
   AddCXXSynthetic(
       objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
       "NSMutableSet synthetic children", ConstString("NSMutableSet"),
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
       "NSOrderedSet synthetic children", ConstString("NSOrderedSet"),
       ScriptedSyntheticChildren::Flags());

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSContainer.py

 class ObjCDataFormatterNSContainer(ObjCDataFormatterTestCase):
 
     @skipUnlessDarwin
     def test_nscontainers_with_run_command(self):
         """Test formatters for  NS container classes."""
         self.appkit_tester_impl(self.nscontainers_data_formatter_commands)
 
     def nscontainers_data_formatter_commands(self):
+        
         self.expect(
             'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary cfarray_ref mutable_array_ref',
             substrs=[
                 '(NSArray *) newArray = ',
                 ' @"50 elements"',
                 '(NSDictionary *) nsDictionary = ',
                 ' 2 key/value pairs',
                 '(NSDictionary *) newDictionary = ',
                 ' 12 key/value pairs',
+                '(NSDictionary *) nscfDictionary = ',
+                ' 4 key/value pairs',
                 '(CFDictionaryRef) cfDictionaryRef = ',
                 ' 3 key/value pairs',
                 '(NSDictionary *) newMutableDictionary = ',
                 ' 21 key/value pairs',
                 '(CFArrayRef) cfarray_ref = ',
                 ' @"3 elements"',
                 '(CFMutableArrayRef) mutable_array_ref = ',
                 ' @"11 elements"',
             ])
 
         self.expect(
+            'frame variable -d run-target *nscfDictionary',
+            patterns=[
+                '\(__NSCFDictionary\) \*nscfDictionary =',
+                'key = 0x.* @"foo"',
+                'value = 0x.* @"foo"',
+                'key = 0x.* @"bar"',
+                'value = 0x.* @"bar"',
+                'key = 0x.* @"baz"',
+                'value = 0x.* @"baz"',
+                'key = 0x.* @"quux"',
+                'value = 0x.* @"quux"',
+                ])
+                
+                
+        self.expect(
+          'frame var nscfSet',
+          substrs=[
+          '(NSSet *) nscfSet = ',
+          '2 elements',
+          ])
+          
+        self.expect(
+          'frame variable -d run-target *nscfSet',
+          patterns=[
+              '\(__NSCFSet\) \*nscfSet =',
+              '\[0\] = 0x.* @".*"',
+              '\[1\] = 0x.* @".*"',
+                    ])
+                  
+        self.expect(
             'frame variable iset1 iset2 imset',
             substrs=['4 indexes', '512 indexes', '10 indexes'])
 
         self.expect(
             'frame variable binheap_ref',
             substrs=['(CFBinaryHeapRef) binheap_ref = ', '@"21 items"'])
 
         self.expect(
             'expression -d run -- (NSArray*)[NSArray new]',
             substrs=['@"0 elements"'])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/main.m

NSString *hebrew = [NSString stringWithString:@"לילה טוב"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar14"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar15"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar16"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar17"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar18"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar19"];
       [newMutableDictionary setObject:@"foo" forKey:@"bar20"];
 
-      id cfKeys[2] = { @"foo", @"bar", @"baz", @"quux" };
-      id cfValues[2] = { @"foo", @"bar", @"baz", @"quux" };
-      NSDictionary *nsDictionary = CFBridgingRelease(CFDictionaryCreate(nil, (void *)cfKeys, (void *)cfValues, 2, nil, nil));
-      CFDictionaryRef cfDictionaryRef = CFDictionaryCreate(nil, (void *)cfKeys, (void *)cfValues, 3, nil, nil);
+            id cfKeys[4] = {@"foo", @"bar", @"baz", @"quux"};
+            id cfValues[4] = {@"foo", @"bar", @"baz", @"quux"};
+            NSDictionary *nsDictionary = CFBridgingRelease(CFDictionaryCreate(nil, (void *)cfKeys, (void *)cfValues, 2, nil, nil));
+            NSDictionary *nscfDictionary = CFBridgingRelease(CFDictionaryCreate(
+                nil, (void *)cfKeys, (void *)cfValues, 4, nil, nil));
+            CFDictionaryRef cfDictionaryRef = CFDictionaryCreate(nil, (void *)cfKeys, (void *)cfValues, 3, nil, nil);
 
       NSAttributedString* attrString = [[NSAttributedString alloc] initWithString:@"hello world from foo" attributes:newDictionary];
       [attrString isEqual:nil];
       NSAttributedString* mutableAttrString = [[NSMutableAttributedString alloc] initWithString:@"hello world from foo" attributes:newDictionary];
       [mutableAttrString isEqual:nil];
 
       NSString* mutableString = [[NSMutableString alloc] initWithString:@"foo"];
       [mutableString insertString:@"foo said this string needs to be very long so much longer than whatever other string has been seen ever before by anyone of the mankind that of course this is still not long enough given what foo our friend foo our lovely dearly friend foo desired of us so i am adding more stuff here for the sake of it and for the joy of our friend who is named guess what just foo. hence, dear friend foo, stay safe, your string is now  long enough to accommodate your testing need and I will make sure that if not we extend it with even more fuzzy random meaningless words pasted one after the other from a long tiresome friday evening spent working in my office. my office mate went home but I am still randomly typing just for the fun of seeing what happens of the length of a Mutable String in Cocoa if it goes beyond one byte.. so be it, dear " atIndex:0];
NSString *hebrew = [NSString stringWithString:@"לילה טוב"];
       [mutableData appendBytes:"MOREDATA" length:8];
 
       [immutableData length];
       [mutableData length];
 
       NSSet* nsset = [[NSSet alloc] initWithObjects:str1,str2,str3,nil];
       NSSet *nsmutableset = [[NSMutableSet alloc] initWithObjects:str1,str2,str3,nil];
       [nsmutableset addObject:str4];
+            NSSet *nscfSet =
+                CFBridgingRelease(CFSetCreate(nil, (void *)cfValues, 2, nil));
 
-      CFDataRef data_ref = CFDataCreate(kCFAllocatorDefault, [immutableData bytes], 5);
+            CFDataRef data_ref = CFDataCreate(kCFAllocatorDefault, [immutableData bytes], 5);
 
       CFMutableDataRef mutable_data_ref = CFDataCreateMutable(kCFAllocatorDefault, 8);
       CFDataAppendBytes(mutable_data_ref, [mutableData bytes], 5);
 
       CFMutableStringRef mutable_string_ref = CFStringCreateMutable(NULL,100);
       CFStringAppend(mutable_string_ref, CFSTR("Wish ya knew"));
 
       CFStringRef cfstring_ref = CFSTR("HELLO WORLD");