[Data formatters] Make NSSetM support both old- and new-style representation

[spyffe]

Summary

NSSetM has two in-memory representations depending on what Foundation version is in use.
This patch separates the two.

[jasonmolenda]

Good use of templates, looks good to me.

[lhames]

Otherwise LGTM. :)

source/Plugins/Language/ObjC/NSSet.cpp

134–135 ↗

(On Diff #104695)

I think we prefer using to typedef these days.

153–154 ↗

(On Diff #104695)

Ditto here.

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

 //===-- NSSet.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "NSSet.h"
 
+#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.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 NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+template <typename D32, typename D64>
+class GenericNSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
-  NSSetMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+  GenericNSSetMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
-  ~NSSetMSyntheticFrontEnd() override;
+  ~GenericNSSetMSyntheticFrontEnd() override;
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(const 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;
+  D32 *m_data_32;
+  D64 *m_data_64;
+  std::vector<SetItemDescriptor> m_children;
+};
+  
+namespace Foundation1300 {
   struct DataDescriptor_32 {
     uint32_t _used : 26;
     uint32_t _size;
     uint32_t _mutations;
     uint32_t _objs_addr;
   };
   
   struct DataDescriptor_64 {
     uint64_t _used : 58;
     uint64_t _size;
     uint64_t _mutations;
     uint64_t _objs_addr;
   };
   
-  struct SetItemDescriptor {
-    lldb::addr_t item_ptr;
-    lldb::ValueObjectSP valobj_sp;
+  using NSSetMSyntheticFrontEnd =
+      GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
+}
+  
+namespace Foundation1400 {
+  struct DataDescriptor_32 {
+    uint32_t _used : 26;
+    uint32_t _size;
+    uint32_t _objs_addr;
+    uint32_t _mutations;
   };
   
-  ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  DataDescriptor_32 *m_data_32;
-  DataDescriptor_64 *m_data_64;
-  std::vector<SetItemDescriptor> m_children;
+  struct DataDescriptor_64 {
+    uint64_t _used : 58;
+    uint64_t _size;
+    uint64_t _objs_addr;
+    uint64_t _mutations;
   };
   
+  using NSSetMSyntheticFrontEnd =
+      GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
+}
+  
 class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSSetCodeRunningSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   ~NSSetCodeRunningSyntheticFrontEnd() override;
 
   size_t CalculateNumChildren() override;
 
lldb_private::formatters::NSSetSyntheticFrontEndCreator(
   const char *class_name = class_name_cs.GetCString();
 
   if (!class_name || !*class_name)
     return nullptr;
 
   if (!strcmp(class_name, "__NSSetI")) {
     return (new NSSetISyntheticFrontEnd(valobj_sp));
   } else if (!strcmp(class_name, "__NSSetM")) {
-    return (new NSSetMSyntheticFrontEnd(valobj_sp));
+    AppleObjCRuntime *apple_runtime =
+        llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
+    if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1400)
+      return (new Foundation1400::NSSetMSyntheticFrontEnd(valobj_sp));
+    else
+      return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
   } else {
     auto &map(NSSet_Additionals::GetAdditionalSynthetics());
     auto iter = map.find(class_name_cs), end = map.end();
     if (iter != end)
       return iter->second(synth, valobj_sp);
     return nullptr;
   }
 }
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::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd(
+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_private::formatters::NSSetMSyntheticFrontEnd::~NSSetMSyntheticFrontEnd() {
+template <typename D32, typename D64>
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::~GenericNSSetMSyntheticFrontEnd() {
   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::NSSetMSyntheticFrontEnd::GetIndexOfChildWithName(
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::GetIndexOfChildWithName(
     const 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>
 size_t
-lldb_private::formatters::NSSetMSyntheticFrontEnd::CalculateNumChildren() {
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::CalculateNumChildren() {
   if (!m_data_32 && !m_data_64)
     return 0;
   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 }
 
-bool lldb_private::formatters::NSSetMSyntheticFrontEnd::Update() {
+template <typename D32, typename D64>
+bool
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::Update() {
   m_children.clear();
   ValueObjectSP valobj_sp = m_backend.GetSP();
   m_ptr_size = 0;
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
   m_data_64 = nullptr;
   if (!valobj_sp)
lldb_private::formatters::
   }
   error.Clear();
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return false;
   m_ptr_size = process_sp->GetAddressByteSize();
   uint64_t data_location = valobj_sp->GetAddressOf() + 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),
+    m_data_32 = new D32();
+    process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
                            error);
   } else {
-    m_data_64 = new DataDescriptor_64();
-    process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
+    m_data_64 = new D64();
+    process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
                            error);
   }
   if (error.Fail())
     return false;
   return false;
 }
 
-bool lldb_private::formatters::NSSetMSyntheticFrontEnd::MightHaveChildren() {
+template <typename D32, typename D64>
+bool
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::MightHaveChildren() {
   return true;
 }
 
+template <typename D32, typename D64>
 lldb::ValueObjectSP
-lldb_private::formatters::NSSetMSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
+lldb_private::formatters::
+  GenericNSSetMSyntheticFrontEnd<D32, D64>::GetChildAtIndex(size_t idx) {
   lldb::addr_t m_objs_addr =
       (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
 
   uint32_t num_children = CalculateNumChildren();
 
   if (idx >= num_children)
     return lldb::ValueObjectSP();