[lldb/Dataformatter] Add support to CF{Dictionary,Set}Ref types

[mib]

Summary

This patch improves data formatting for CFDictionaryRef and CFSetRef.
It uses the same data-formatter as NSCFDictionaries and NSCFSets introduced
previously but did require some adjustments in Core::ValueObject.

Since the "Ref" types are opaque pointers to the actual CF containers, if the
value object has a synthetic value, lldb will use the opaque pointer's pointee
type to create the new ValueObjectChild needed to dereference the ValueObject.
This allows the "Ref" types to behaves the same as CF containers when used with
the frame variable command, the SBAPI or in Xcode's variable inspector.

rdar://53104287

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

[friss]

lldb/source/Core/ValueObject.cpp

52

You don't want to introduce a dependency between Core and a plugin. What you need here might need to be introduced as a new abstract functionality on the TypeSystem base class.

2837

I am understanding correctly that this condition will only trigger when there's a synthetic child provider for the type? In other words, if we have an opaque pointer that we don't know how to display, it will still cause an error, right?

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

59–60

I must be missing something obvious, but it seems like that patch doesn't register a formatter for CFDictionaryRef. Was it already there but non-functional?

[labath]

The ValueObject change looks very worrying to me. The ability to pretty-print incomplete types seems pretty useful, but the implementation of that looks a bit... scary. I mean you're not even checking whether the incomplete type is a struct or an enum. And the effect of forcefully creating a empty struct has impact outside of the pretty-printer. Maybe it would be better if we thought the valueobject/pretty-printer machinery to work with incomplete types?

Raphael, what do you make of all of this?

Also would it be possible to test the ValueObject functionality on a c++ test (an incomplete c++ type with a custom pretty printer), so that test can run every where?

[teemperor]

I don't really know that ValueObject code, but I wish we could just pretend that the dereferenced type of X is a type named Y or something like that and then just map *Ref classes to their non-opaque bridged types when dereferenced. No idea if that's possible though.

Anyway, if we go with the fake empty struct approach then I wish we could just use the (fixed?) list of these special bridged structs and hard-code them into some ObjC plugin or something like that. If those few selected classes are manually completed as empty structs when we find them in the debug info then I think that's a manageable workaround to get this running.

lldb/source/Core/ValueObject.cpp

663

This change (and the one below) don't seem to be some NFC refactoring? Not sure why this was refactored as compiler_type is only ever used once where we previously called GetCompilerType()?

2844

This is the name of the typedef, not the underlying incomplete struct. So this creates a new empty record with the name of the typedef which seems weird. If we fake that some type is actually empty instead of incomplete, then I think the underlying struct makes more sense to emulate. Also this variable name is kinda weird with it's g____ prefix even though it's not a global or a static.

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

58

Trailing spaces (that Phabricator somehow doesn't properly highlight :/)

[mib]

lldb/source/Core/ValueObject.cpp

663

This is a remaining from a previous change that I ended up not removing. I'll change it back the way it was.

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

59–60

The string summary worked but not the synthetic child provider.

[shafik]

I have to agree w/ Pavel here that I am not crazy about creating creating an empty struct here, it is not clear why there is no other way.

[jingham]

The way the ValueObject code works w.r.t. Synthetic child providers is that you first look up and make a ValueObject for the actual value the user requested, (for instance a ValueObjectVariable or a ValueObjectChild or a ValueObjectConstResult for expressions, etc.), then you hand that to the printer. The printer will look at whether the current settings prefer Synthetic Values, and if they do they ask the actual value if it has any Synthetic children. So when you do something like:

(lldb) frame var *opaque_ptr

we first have to make a ValueObject for *opaque_ptr (in this case the dereference is a ValueObjectChild of the ValueObjectVariable representing the variable opaque_ptr and return that to the printer.

But you can't currently make a ValueObject that doesn't have a type, and the problem here is that we don't have a type for * of the opaque pointer. Making an empty struct definition and returning a ValueObject with that struct definition is one fairly straightforward way of doing that. And we already inject custom types in other places to manage synthetic children (look for __lldb_autogen_nspair for instance). So this seemed the most straightforward choice.

Note, you could also make a new ValueObject subclass for these purposes: ValueObjectOpaqueDereference to forward the Synthetic Children. The ValueObject base class doesn't require a type so you could make such a thing. But it would somehow fake handing out the type so you'd have to be careful how you did that. Then its job would be to hand out the synthetic children. If people really hate making the fake structure we could go this way instead, but it seems better to use an extant facility if we can, and "fake handing out the type" seems to me at least as dangerous as injecting synthesized types into the TypeSystem. The latter we already do, the former we don't.

I'm not happy with the notion of just hard-coding this to CF types or making it about bridged types at all. It is not uncommon to have a client library that vends opaque pointers, but you've figured out what some of the fields are. One solution to debugging this scenario is to introduce another shadow type, either in lldb or actually in your code, and cast types to that when printing. But that means you can't use "frame var" since it doesn't support casting, and you have to remember to cast every time in the expression parser which is annoying. if you made a synthetic child provider, and if what Ismail is trying to get working here works generally, then once you've made the provider, you can just print * of the pointer, and it will work. So I think this should be a general facility for opaque pointer types with synthetic child providers. So I'd much prefer to keep this a general facility.

[mib]

lldb/source/Core/ValueObject.cpp

52

I'll change this before updating the differential with the fixes.

2837

Yes, from my understanding, if the opaque pointer doesn't have any synthetic child provider, it won't have a synthetic value and lldb should error saying error: dereference failed.

[jingham]

lldb/source/Core/ValueObject.cpp

2837

We should add a test to make sure this stays true.

[mib]

• Added a virtual method to create an empty struct type TypeSystem::GetEmptyStructType (if someone can think of a better name, I'm open to suggestions)
• Refactored ValueObject::Dereference
• Reverted the NFC changes in ValueObject::CreateChildAtIndex
• Added test for C++ incomplete type with data-formatter (WIP)

[teemperor]

I don't see a huge problem with things like __lldb_autogen_nspair as it's a single obviously generated type hardcoded into LLDB. But this really generic approach here can generate all kind of structs whenever some formatter decides that some random incomplete record has a synthetic value.

But in any case, I think we're kind of talking about different problems here. We do have the following type:

TypedefType 0x7fc9cd04f440 'CFDictionaryRef' sugar
|-Typedef 0x7fc9cd04f3e0 'CFDictionaryRef'
`-PointerType 0x7fc9cd04f3a0 'const struct __CFDictionary *'
  `-QualType 0x7fc9cd04f381 'const struct __CFDictionary' const
    `-RecordType 0x7fc9cd04f380 'struct __CFDictionary'
      `-CXXRecord 0x7fc9cd04f2d0 '__CFDictionary'

So we do have an underlying type for *CFDictionaryRef which is just the __CFDictionary record. The problem is just that this is an incomplete type. So we could make a ValueObject that has an incomplete struct type which seems to work for me just fine? We probably need to adjust the formatter for this prints an actual empty value: (const __CFDictionary) *dict = {}

lldb/source/Core/ValueObject.cpp

2844

This is still the name of the typedef:

child_compiler_type =
    type_system->GetEmptyStructType(compiler_type.GetTypeName());

So we end up with an AST like we get from here:

typedef NSDictionary* CFDictionaryRef;
struct CFDictionaryRef {}; // conflict

This should at least have some kind of __lldb_made_up_type_unique_stringy_ prefix in the generated name to make this not ambiguous.

Also a log statement would be useful that we know when these types are created when someone reports a bug.

[labath]

In D79554#2026999, @teemperor wrote:

I don't see a huge problem with things like __lldb_autogen_nspair as it's a single obviously generated type hardcoded into LLDB. But this really generic approach here can generate all kind of structs whenever some formatter decides that some random incomplete record has a synthetic value.

But in any case, I think we're kind of talking about different problems here. We do have the following type:

TypedefType 0x7fc9cd04f440 'CFDictionaryRef' sugar
|-Typedef 0x7fc9cd04f3e0 'CFDictionaryRef'
`-PointerType 0x7fc9cd04f3a0 'const struct __CFDictionary *'
  `-QualType 0x7fc9cd04f381 'const struct __CFDictionary' const
    `-RecordType 0x7fc9cd04f380 'struct __CFDictionary'
      `-CXXRecord 0x7fc9cd04f2d0 '__CFDictionary'

So we do have an underlying type for *CFDictionaryRef which is just the __CFDictionary record. The problem is just that this is an incomplete type. So we could make a ValueObject that has an incomplete struct type which seems to work for me just fine? We probably need to adjust the formatter for this prints an actual empty value: (const __CFDictionary) *dict = {}

That's exactly what I was thinking. As the CompilerType abstraction is already capable of representing incomplete types, and our goal is to construct synthetic children ( == ValueObjects) for these types, then it seems reasonable for ValueObjects to operate on these incomplete types. I mean, one won't be able to do much with them, but it should be possible to take their address and then grovel in that memory, or cast it to something else (and I assume that's what these pretty printers will be doing).

[mib]

Instead of creating a new empty struct type, this new implementation will use the opaque pointer's pointee type to create the new ValueObjectChild.
This makes the previously introduced helper function in TypeSystem and TypeSystemClang useless, so I got rid of them.

[teemperor]

IMHO this looks good now. Maybe add a comment to the commit that this adds support for incomplete types in ValueObjects.

I think @jingham should also take a look at this to make sure this makes sense.

lldb/source/Core/ValueObjectSyntheticFilter.cpp

56–58

Maybe comment this line that copying the data of an incomplete type doesn't make sense as it has no (byte) size. (Previously this worked as our made-up type was empty and had a size of 0 bytes.)

[labath]

lldb/source/Core/ValueObject.cpp

2833–2855

Can this be merged with the code above? It seems like the only difference is the way it which we get the CompilerType.

2836

What's the reason for limiting this to the C family? It seems like one could want to have a pretty printer for incomplete types in any language...

[labath]

lldb/source/Core/ValueObject.cpp

690–694

I'm getting a crash here when attempting to dereference incomplete c(++) types. The simplest (albeit contrived) repro is:

$ cat /tmp/a.c 
struct incomplete;

struct incomplete *var = (struct incomplete *)0xdead;

int main() {}
$ clang /tmp/a.c -o /tmp/a.out -g
$ lldb /tmp/a.out -o "target variable var[0]"
(lldb) target create "/tmp/a.out"
Current executable set to '/tmp/a.out' (x86_64).
(lldb) target variable var[0]
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.	Program arguments: lldb /tmp/a.out -o target variable var[0] 
 #0 0x0000561dcd331cea llvm::sys::PrintStackTrace(llvm::raw_ostream&) (lldb+0x29cea)
 #1 0x0000561dcd32ffc4 llvm::sys::RunSignalHandlers() (lldb+0x27fc4)
 #2 0x0000561dcd330108 SignalHandler(int) (lldb+0x28108)
 #3 0x00007f62b35175b0 __restore_rt (/lib64/libpthread.so.0+0x135b0)
 #4 0x00007f62ae9235fc lldb_private::ValueObject::CreateChildAtIndex(unsigned long, bool, int) (../lib/liblldb.so.11git+0xb985fc)
 #5 0x00007f62ae923e2b lldb_private::ValueObject::GetSyntheticArrayMember(unsigned long, bool) (../lib/liblldb.so.11git+0xb98e2b)
...

[mib]

@labath Thanks for reporting that crash. D83327 should fix the issue.

lldb/source/Core/ValueObject.cpp

 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-private-types.h"
 
 #include "llvm/Support/Compiler.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
 #include <tuple>
 
 #include <assert.h>
ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
   bool ignore_array_bounds = synthetic_array_member;
   std::string child_name_str;
   uint32_t child_byte_size = 0;
   int32_t child_byte_offset = 0;
   uint32_t child_bitfield_bit_size = 0;
   uint32_t child_bitfield_bit_offset = 0;
   bool child_is_base_class = false;
   bool child_is_deref_of_parent = false;
   uint64_t language_flags = 0;
 
   const bool transparent_pointers = !synthetic_array_member;
   CompilerType child_compiler_type;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
   child_compiler_type = GetCompilerType().GetChildCompilerTypeAtIndex(
       &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
if (child_compiler_type) {
 
     valobj = new ValueObjectChild(
         *this, child_compiler_type, child_name, child_byte_size,
         child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
         child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
         language_flags);
   }
 
+  if (!valobj && synthetic_array_member)
+    valobj = GetSyntheticValue()
+                 ->GetChildAtIndex(synthetic_index, synthetic_array_member)
+                 .get();
+
   return valobj;
 }
 
 bool ValueObject::GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
                                       std::string &destination,
                                       lldb::LanguageType lang) {
   return GetSummaryAsCString(summary_ptr, destination,
                              TypeSummaryOptions().SetLanguage(lang));
if (child_compiler_type && child_byte_size) {
         child_name.SetCString(child_name_str.c_str());
 
       m_deref_valobj = new ValueObjectChild(
           *this, child_compiler_type, child_name, child_byte_size,
           child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
           child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
           language_flags);
     }
+
+    // In case of incomplete child compiler type, use the pointee type and try
+    // to recreate a new ValueObjectChild using it.
+    if (!m_deref_valobj) {
+      if (HasSyntheticValue()) {
+        child_compiler_type = compiler_type.GetPointeeType();
+
+        if (child_compiler_type) {
+          ConstString child_name;
+          if (!child_name_str.empty())
+            child_name.SetCString(child_name_str.c_str());
+
+          m_deref_valobj = new ValueObjectChild(
+              *this, child_compiler_type, child_name, child_byte_size,
+              child_byte_offset, child_bitfield_bit_size,
+              child_bitfield_bit_offset, child_is_base_class,
+              child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
+        }
+      }
+    }
+
   } else if (HasSyntheticValue()) {
     m_deref_valobj =
         GetSyntheticValue()
             ->GetChildMemberWithName(ConstString("$$dereference$$"), true)
             .get();
   } else if (IsSynthetic()) {
     m_deref_valobj =
         GetChildMemberWithName(ConstString("$$dereference$$"), true).get();
   }
 
   if (m_deref_valobj) {

lldb/source/Core/ValueObjectSyntheticFilter.cpp

ValueObjectSynthetic::ValueObjectSynthetic(ValueObject &parent,
                                            lldb::SyntheticChildrenSP filter)
     : ValueObject(parent), m_synth_sp(filter), m_children_byindex(),
       m_name_toindex(), m_synthetic_children_cache(),
       m_synthetic_children_count(UINT32_MAX),
       m_parent_type_name(parent.GetTypeName()),
       m_might_have_children(eLazyBoolCalculate),
       m_provides_value(eLazyBoolCalculate) {
   SetName(parent.GetName());
+  // Copying the data of an incomplete type won't work as it has no byte size.
+  if (m_parent->GetCompilerType().IsCompleteType())
     CopyValueData(m_parent);
   CreateSynthFilter();
 }
 
 ValueObjectSynthetic::~ValueObjectSynthetic() = default;
 
 CompilerType ValueObjectSynthetic::GetCompilerTypeImpl() {
   return m_parent->GetCompilerType();
 }
if (synth_val && synth_val->CanProvideValue()) {
     CopyValueData(synth_val.get());
   } else {
     LLDB_LOGF(log,
               "[ValueObjectSynthetic::UpdateValue] name=%s, synthetic "
               "filter said it will not provide a value",
               GetName().AsCString());
 
     m_provides_value = eLazyBoolNo;
+    // Copying the data of an incomplete type won't work as it has no byte size.
+    if (m_parent->GetCompilerType().IsCompleteType())
       CopyValueData(m_parent);
   }
 
   SetValueIsValid(true);
   return true;
 }
 
 lldb::ValueObjectSP ValueObjectSynthetic::GetChildAtIndex(size_t idx,
                                                           bool can_create) {

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

bool lldb_private::formatters::NSDictionarySummaryProvider(
   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_Dictionary1("__NSSingleEntryDictionaryI");
   static const ConstString g_Dictionary0("__NSDictionary0");
-  static const ConstString g_DictionaryCF("__NSCFDictionary");
+  static const ConstString g_DictionaryCF("__CFDictionary");
+  static const ConstString g_DictionaryNSCF("__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) {
     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 if (class_name == g_DictionaryCF || class_name == g_DictionaryCFRef) {
+  } else if (class_name == g_DictionaryCF ||
+             class_name == g_DictionaryNSCF ||
+             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) {
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_DictionaryCF("__CFDictionary");
+  static const ConstString g_DictionaryNSCF("__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) {
+  } else if (class_name == g_DictionaryCF ||
+             class_name == g_DictionaryNSCF ||
+             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);
     }
   }

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

bool lldb_private::formatters::NSSetSummaryProvider(
   uint64_t value = 0;
 
   ConstString class_name(descriptor->GetClassName());
 
   static const ConstString g_SetI("__NSSetI");
   static const ConstString g_OrderedSetI("__NSOrderedSetI");
   static const ConstString g_SetM("__NSSetM");
   static const ConstString g_SetCF("__NSCFSet");
+  static const ConstString g_SetCFRef("CFSetRef");
 
   if (class_name.IsEmpty())
     return false;
 
   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 (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) {
+  } else if (class_name == g_SetCF || class_name == g_SetCFRef) {
     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), end = map.end();
if (!descriptor || !descriptor->IsValid())
     return nullptr;
 
   ConstString class_name = descriptor->GetClassName();
 
   static const ConstString g_SetI("__NSSetI");
   static const ConstString g_OrderedSetI("__NSOrderedSetI");
   static const ConstString g_SetM("__NSSetM");
   static const ConstString g_SetCF("__NSCFSet");
+  static const ConstString g_SetCFRef("CFSetRef");
 
   if (class_name.IsEmpty())
     return nullptr;
 
   if (class_name == g_SetI || class_name == g_OrderedSetI) {
     return (new NSSetISyntheticFrontEnd(valobj_sp));
   } 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) {
+  } else if (class_name == g_SetCF || class_name == g_SetCFRef) {
     return (new NSCFSetSyntheticFrontEnd(valobj_sp));
   } else {
     auto &map(NSSet_Additionals::GetAdditionalSynthetics());
     auto iter = map.find(class_name), end = map.end();
     if (iter != end)
       return iter->second(synth, valobj_sp);
     return nullptr;
   }

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

AddCXXSummary(objc_category_sp,
                 "NSDictionary summary provider", ConstString("__NSDictionaryM"),
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<true>,
                 "NSDictionary summary provider", ConstString("CFDictionaryRef"),
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<true>,
+                "NSDictionary summary provider", ConstString("__CFDictionary"),
+                appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDictionarySummaryProvider<true>,
                 "NSDictionary summary provider",
                 ConstString("CFMutableDictionaryRef"), appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
                 "NSSet summary", ConstString("NSSet"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
       "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<true>,
                 "CFSetRef summary", ConstString("CFSetRef"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>,
       "CFMutableSetRef summary", ConstString("CFMutableSetRef"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
                 "__NSCFSet summary", ConstString("__NSCFSet"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
+                "__CFSet summary", ConstString("__CFSet"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
                 "__NSSetI summary", ConstString("__NSSetI"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
                 "__NSSetM summary", ConstString("__NSSetM"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
       "NSCountedSet summary", ConstString("NSCountedSet"), appkit_flags);
   AddCXXSummary(
AddCXXSynthetic(
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
       "NSDictionary synthetic children", ConstString("CFDictionaryRef"),
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
       "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"),
       ScriptedSyntheticChildren::Flags());
+  AddCXXSynthetic(
+      objc_category_sp,
+      lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
+      "NSDictionary synthetic children", ConstString("__CFDictionary"),
+      ScriptedSyntheticChildren::Flags());
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSErrorSyntheticFrontEndCreator,
                   "NSError synthetic children", ConstString("NSError"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSExceptionSyntheticFrontEndCreator,
                   "NSException synthetic children", ConstString("NSException"),
static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   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,
+                  "CFSetRef synthetic children", ConstString("CFSetRef"),
+                  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());
   AddCXXSynthetic(
       objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
       "__NSOrderedSetI synthetic children", ConstString("__NSOrderedSetI"),
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
       "__NSOrderedSetM synthetic children", ConstString("__NSOrderedSetM"),
       ScriptedSyntheticChildren::Flags());
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+                  "__CFSet synthetic children", ConstString("__CFSet"),
+                  ScriptedSyntheticChildren::Flags());
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSIndexPathSyntheticFrontEndCreator,
                   "NSIndexPath synthetic children", ConstString("NSIndexPath"),
                   ScriptedSyntheticChildren::Flags());
 
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::CFBagSummaryProvider,

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

def nscontainers_data_formatter_commands(self):
                 ' @"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',
+                ' 2 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',
+            'frame variable -d run-target *cfDictionaryRef',
+            patterns=[
+                '\(const __CFDictionary\) \*cfDictionaryRef =',
+                'key = 0x.* @"foo"',
+                'value = 0x.* @"foo"',
+                'key = 0x.* @"bar"',
+                'value = 0x.* @"bar"',
+                ])
+
+
+        self.expect(
+          'frame var nscfSet cfSetRef',
           substrs=[
           '(NSSet *) nscfSet = ',
           '2 elements',
+          '(CFSetRef) cfSetRef = ',
+          '2 elements',
           ])
 
         self.expect(
           'frame variable -d run-target *nscfSet',
           patterns=[
               '\(__NSCFSet\) \*nscfSet =',
               '\[0\] = 0x.* @".*"',
               '\[1\] = 0x.* @".*"',
                     ])
 
         self.expect(
+          'frame variable -d run-target *cfSetRef',
+          patterns=[
+              '\(const __CFSet\) \*cfSetRef =',
+              '\[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

int main(int argc, const char *argv[]) {
   [newMutableDictionary setObject:@"foo" forKey:@"bar20"];
 
   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);
+  CFDictionaryRef cfDictionaryRef = (__bridge CFDictionaryRef)nsDictionary;
 
   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];
int main(int argc, const char *argv[]) {
   [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));
+  CFSetRef cfSetRef = (__bridge CFSetRef)nscfSet;
 
   CFDataRef data_ref =
       CFDataCreate(kCFAllocatorDefault, [immutableData bytes], 5);
 
   CFMutableDataRef mutable_data_ref =
       CFDataCreateMutable(kCFAllocatorDefault, 8);
   CFDataAppendBytes(mutable_data_ref, [mutableData bytes], 5);