contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp

   1 //===-- NSSet.cpp -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "NSSet.h"
  15
  16 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
  17 #include "lldb/Core/ValueObject.h"
  18 #include "lldb/Core/ValueObjectConstResult.h"
  19 #include "lldb/DataFormatters/FormattersHelpers.h"
  20 #include "lldb/Symbol/ClangASTContext.h"
  21 #include "lldb/Target/Language.h"
  22 #include "lldb/Target/ObjCLanguageRuntime.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Utility/DataBufferHeap.h"
  25 #include "lldb/Utility/Endian.h"
  26 #include "lldb/Utility/Status.h"
  27 #include "lldb/Utility/Stream.h"
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31 using namespace lldb_private::formatters;
  32
  33 std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
  34 NSSet_Additionals::GetAdditionalSummaries() {
  35   static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
  36   return g_map;
  37 }
  38
  39 std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> &
  40 NSSet_Additionals::GetAdditionalSynthetics() {
  41   static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>
  42       g_map;
  43   return g_map;
  44 }
  45
  46 namespace lldb_private {
  47 namespace formatters {
  48 class NSSetISyntheticFrontEnd : public SyntheticChildrenFrontEnd {
  49 public:
  50   NSSetISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
  51
  52   ~NSSetISyntheticFrontEnd() override;
  53
  54   size_t CalculateNumChildren() override;
  55
  56   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
  57
  58   bool Update() override;
  59
  60   bool MightHaveChildren() override;
  61
  62   size_t GetIndexOfChildWithName(const ConstString &name) override;
  63
  64 private:
  65   struct DataDescriptor_32 {
  66     uint32_t _used : 26;
  67     uint32_t _szidx : 6;
  68   };
  69
  70   struct DataDescriptor_64 {
  71     uint64_t _used : 58;
  72     uint32_t _szidx : 6;
  73   };
  74
  75   struct SetItemDescriptor {
  76     lldb::addr_t item_ptr;
  77     lldb::ValueObjectSP valobj_sp;
  78   };
  79
  80   ExecutionContextRef m_exe_ctx_ref;
  81   uint8_t m_ptr_size;
  82   DataDescriptor_32 *m_data_32;
  83   DataDescriptor_64 *m_data_64;
  84   lldb::addr_t m_data_ptr;
  85   std::vector<SetItemDescriptor> m_children;
  86 };
  87
  88 template <typename D32, typename D64>
  89 class GenericNSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
  90 public:
  91   GenericNSSetMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
  92
  93   ~GenericNSSetMSyntheticFrontEnd() override;
  94
  95   size_t CalculateNumChildren() override;
  96
  97   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
  98
  99   bool Update() override;
 100
 101   bool MightHaveChildren() override;
 102
 103   size_t GetIndexOfChildWithName(const ConstString &name) override;
 104
 105 private:
 106
 107   struct SetItemDescriptor {
 108     lldb::addr_t item_ptr;
 109     lldb::ValueObjectSP valobj_sp;
 110   };
 111
 112   ExecutionContextRef m_exe_ctx_ref;
 113   uint8_t m_ptr_size;
 114   D32 *m_data_32;
 115   D64 *m_data_64;
 116   std::vector<SetItemDescriptor> m_children;
 117 };
 118
 119 namespace Foundation1300 {
 120   struct DataDescriptor_32 {
 121     uint32_t _used : 26;
 122     uint32_t _size;
 123     uint32_t _mutations;
 124     uint32_t _objs_addr;
 125   };
 126
 127   struct DataDescriptor_64 {
 128     uint64_t _used : 58;
 129     uint64_t _size;
 130     uint64_t _mutations;
 131     uint64_t _objs_addr;
 132   };
 133
 134   using NSSetMSyntheticFrontEnd =
 135       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 136 }
 137
 138 namespace Foundation1428 {
 139   struct DataDescriptor_32 {
 140     uint32_t _used : 26;
 141     uint32_t _size;
 142     uint32_t _objs_addr;
 143     uint32_t _mutations;
 144   };
 145
 146   struct DataDescriptor_64 {
 147     uint64_t _used : 58;
 148     uint64_t _size;
 149     uint64_t _objs_addr;
 150     uint64_t _mutations;
 151   };
 152
 153   using NSSetMSyntheticFrontEnd =
 154       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 155 }
 156
 157 namespace Foundation1437 {
 158   struct DataDescriptor_32 {
 159     uint32_t _cow;
 160     // __table storage
 161     uint32_t _objs_addr;
 162     union {
 163       uint32_t _mutations;
 164       struct {
 165         uint32_t _muts;
 166         uint32_t _used : 26;
 167         uint32_t _szidx : 6;
 168       };
 169     };
 170   };
 171
 172   struct DataDescriptor_64 {
 173     uint64_t _cow;
 174     // __Table storage
 175     uint64_t _objs_addr;
 176     union {
 177       uint64_t _mutations;
 178       struct {
 179         uint32_t _muts;
 180         uint32_t _used : 26;
 181         uint32_t _szidx : 6;
 182       };
 183     };
 184   };
 185
 186   using NSSetMSyntheticFrontEnd =
 187       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 188
 189   template <typename DD>
 190   uint64_t
 191   __NSSetMSize_Impl(lldb_private::Process &process, lldb::addr_t valobj_addr,
 192                     Status &error) {
 193     const lldb::addr_t start_of_descriptor =
 194         valobj_addr + process.GetAddressByteSize();
 195     DD descriptor = DD();
 196     process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),
 197                        error);
 198     if (error.Fail()) {
 199       return 0;
 200     }
 201     return descriptor._used;
 202   }
 203
 204   uint64_t
 205   __NSSetMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
 206                Status &error) {
 207     if (process.GetAddressByteSize() == 4) {
 208       return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr, error);
 209     } else {
 210       return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr, error);
 211     }
 212   }
 213 }
 214
 215 class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 216 public:
 217   NSSetCodeRunningSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 218
 219   ~NSSetCodeRunningSyntheticFrontEnd() override;
 220
 221   size_t CalculateNumChildren() override;
 222
 223   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 224
 225   bool Update() override;
 226
 227   bool MightHaveChildren() override;
 228
 229   size_t GetIndexOfChildWithName(const ConstString &name) override;
 230 };
 231 } // namespace formatters
 232 } // namespace lldb_private
 233
 234 template <bool cf_style>
 235 bool lldb_private::formatters::NSSetSummaryProvider(
 236     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 237   static ConstString g_TypeHint("NSSet");
 238
 239   ProcessSP process_sp = valobj.GetProcessSP();
 240   if (!process_sp)
 241     return false;
 242
 243   ObjCLanguageRuntime *runtime =
 244       (ObjCLanguageRuntime *)process_sp->GetLanguageRuntime(
 245           lldb::eLanguageTypeObjC);
 246
 247   if (!runtime)
 248     return false;
 249
 250   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 251       runtime->GetClassDescriptor(valobj));
 252
 253   if (!descriptor || !descriptor->IsValid())
 254     return false;
 255
 256   uint32_t ptr_size = process_sp->GetAddressByteSize();
 257   bool is_64bit = (ptr_size == 8);
 258
 259   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
 260
 261   if (!valobj_addr)
 262     return false;
 263
 264   uint64_t value = 0;
 265
 266   ConstString class_name_cs = descriptor->GetClassName();
 267   const char *class_name = class_name_cs.GetCString();
 268
 269   if (!class_name || !*class_name)
 270     return false;
 271
 272   if (!strcmp(class_name, "__NSSetI") ||
 273       !strcmp(class_name, "__NSOrderedSetI")) {
 274     Status error;
 275     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 276                                                       ptr_size, 0, error);
 277     if (error.Fail())
 278       return false;
 279     value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
 280   } else if (!strcmp(class_name, "__NSSetM")) {
 281     AppleObjCRuntime *apple_runtime =
 282         llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
 283     Status error;
 284     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
 285       value = Foundation1437::__NSSetMSize(*process_sp, valobj_addr, error);
 286     } else {
 287       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 288                                                         ptr_size, 0, error);
 289       value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
 290     }
 291     if (error.Fail())
 292       return false;
 293   } else {
 294     auto &map(NSSet_Additionals::GetAdditionalSummaries());
 295     auto iter = map.find(class_name_cs), end = map.end();
 296     if (iter != end)
 297       return iter->second(valobj, stream, options);
 298     else
 299       return false;
 300   }
 301
 302   std::string prefix, suffix;
 303   if (Language *language = Language::FindPlugin(options.GetLanguage())) {
 304     if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
 305                                             suffix)) {
 306       prefix.clear();
 307       suffix.clear();
 308     }
 309   }
 310
 311   stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
 312                 value == 1 ? "" : "s", suffix.c_str());
 313   return true;
 314 }
 315
 316 SyntheticChildrenFrontEnd *
 317 lldb_private::formatters::NSSetSyntheticFrontEndCreator(
 318     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
 319   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 320   if (!process_sp)
 321     return nullptr;
 322   ObjCLanguageRuntime *runtime =
 323       (ObjCLanguageRuntime *)process_sp->GetLanguageRuntime(
 324           lldb::eLanguageTypeObjC);
 325   if (!runtime)
 326     return nullptr;
 327
 328   CompilerType valobj_type(valobj_sp->GetCompilerType());
 329   Flags flags(valobj_type.GetTypeInfo());
 330
 331   if (flags.IsClear(eTypeIsPointer)) {
 332     Status error;
 333     valobj_sp = valobj_sp->AddressOf(error);
 334     if (error.Fail() || !valobj_sp)
 335       return nullptr;
 336   }
 337
 338   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 339       runtime->GetClassDescriptor(*valobj_sp));
 340
 341   if (!descriptor || !descriptor->IsValid())
 342     return nullptr;
 343
 344   ConstString class_name_cs = descriptor->GetClassName();
 345   const char *class_name = class_name_cs.GetCString();
 346
 347   if (!class_name || !*class_name)
 348     return nullptr;
 349
 350   if (!strcmp(class_name, "__NSSetI") ||
 351       !strcmp(class_name, "__NSOrderedSetI")) {
 352     return (new NSSetISyntheticFrontEnd(valobj_sp));
 353   } else if (!strcmp(class_name, "__NSSetM")) {
 354     AppleObjCRuntime *apple_runtime =
 355         llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
 356     if (apple_runtime) {
 357       if (apple_runtime->GetFoundationVersion() >= 1437)
 358         return (new Foundation1437::NSSetMSyntheticFrontEnd(valobj_sp));
 359       else if (apple_runtime->GetFoundationVersion() >= 1428)
 360         return (new Foundation1428::NSSetMSyntheticFrontEnd(valobj_sp));
 361       else
 362         return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
 363     } else {
 364       return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
 365     }
 366   } else {
 367     auto &map(NSSet_Additionals::GetAdditionalSynthetics());
 368     auto iter = map.find(class_name_cs), end = map.end();
 369     if (iter != end)
 370       return iter->second(synth, valobj_sp);
 371     return nullptr;
 372   }
 373 }
 374
 375 lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd(
 376     lldb::ValueObjectSP valobj_sp)
 377     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 378       m_data_32(nullptr), m_data_64(nullptr) {
 379   if (valobj_sp)
 380     Update();
 381 }
 382
 383 lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd() {
 384   delete m_data_32;
 385   m_data_32 = nullptr;
 386   delete m_data_64;
 387   m_data_64 = nullptr;
 388 }
 389
 390 size_t
 391 lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName(
 392     const ConstString &name) {
 393   const char *item_name = name.GetCString();
 394   uint32_t idx = ExtractIndexFromString(item_name);
 395   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 396     return UINT32_MAX;
 397   return idx;
 398 }
 399
 400 size_t
 401 lldb_private::formatters::NSSetISyntheticFrontEnd::CalculateNumChildren() {
 402   if (!m_data_32 && !m_data_64)
 403     return 0;
 404   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 405 }
 406
 407 bool lldb_private::formatters::NSSetISyntheticFrontEnd::Update() {
 408   m_children.clear();
 409   delete m_data_32;
 410   m_data_32 = nullptr;
 411   delete m_data_64;
 412   m_data_64 = nullptr;
 413   m_ptr_size = 0;
 414   ValueObjectSP valobj_sp = m_backend.GetSP();
 415   if (!valobj_sp)
 416     return false;
 417   if (!valobj_sp)
 418     return false;
 419   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 420   Status error;
 421   if (valobj_sp->IsPointerType()) {
 422     valobj_sp = valobj_sp->Dereference(error);
 423     if (error.Fail() || !valobj_sp)
 424       return false;
 425   }
 426   error.Clear();
 427   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 428   if (!process_sp)
 429     return false;
 430   m_ptr_size = process_sp->GetAddressByteSize();
 431   uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size;
 432   if (m_ptr_size == 4) {
 433     m_data_32 = new DataDescriptor_32();
 434     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
 435                            error);
 436   } else {
 437     m_data_64 = new DataDescriptor_64();
 438     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
 439                            error);
 440   }
 441   if (error.Fail())
 442     return false;
 443   m_data_ptr = data_location + m_ptr_size;
 444   return false;
 445 }
 446
 447 bool lldb_private::formatters::NSSetISyntheticFrontEnd::MightHaveChildren() {
 448   return true;
 449 }
 450
 451 lldb::ValueObjectSP
 452 lldb_private::formatters::NSSetISyntheticFrontEnd::GetChildAtIndex(size_t idx) {
 453   uint32_t num_children = CalculateNumChildren();
 454
 455   if (idx >= num_children)
 456     return lldb::ValueObjectSP();
 457
 458   ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
 459   if (!process_sp)
 460     return lldb::ValueObjectSP();
 461
 462   if (m_children.empty()) {
 463     // do the scan phase
 464     lldb::addr_t obj_at_idx = 0;
 465
 466     uint32_t tries = 0;
 467     uint32_t test_idx = 0;
 468
 469     while (tries < num_children) {
 470       obj_at_idx = m_data_ptr + (test_idx * m_ptr_size);
 471       if (!process_sp)
 472         return lldb::ValueObjectSP();
 473       Status error;
 474       obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
 475       if (error.Fail())
 476         return lldb::ValueObjectSP();
 477
 478       test_idx++;
 479
 480       if (!obj_at_idx)
 481         continue;
 482       tries++;
 483
 484       SetItemDescriptor descriptor = {obj_at_idx, lldb::ValueObjectSP()};
 485
 486       m_children.push_back(descriptor);
 487     }
 488   }
 489
 490   if (idx >= m_children.size()) // should never happen
 491     return lldb::ValueObjectSP();
 492
 493   SetItemDescriptor &set_item = m_children[idx];
 494   if (!set_item.valobj_sp) {
 495     auto ptr_size = process_sp->GetAddressByteSize();
 496     DataBufferHeap buffer(ptr_size, 0);
 497     switch (ptr_size) {
 498     case 0: // architecture has no clue?? - fail
 499       return lldb::ValueObjectSP();
 500     case 4:
 501       *((uint32_t *)buffer.GetBytes()) = (uint32_t)set_item.item_ptr;
 502       break;
 503     case 8:
 504       *((uint64_t *)buffer.GetBytes()) = (uint64_t)set_item.item_ptr;
 505       break;
 506     default:
 507       assert(false && "pointer size is not 4 nor 8 - get out of here ASAP");
 508     }
 509     StreamString idx_name;
 510     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 511
 512     DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
 513                        process_sp->GetByteOrder(),
 514                        process_sp->GetAddressByteSize());
 515
 516     set_item.valobj_sp = CreateValueObjectFromData(
 517         idx_name.GetString(), data, m_exe_ctx_ref,
 518         m_backend.GetCompilerType().GetBasicTypeFromAST(
 519             lldb::eBasicTypeObjCID));
 520   }
 521   return set_item.valobj_sp;
 522 }
 523
 524 template <typename D32, typename D64>
 525 lldb_private::formatters::
 526   GenericNSSetMSyntheticFrontEnd<D32, D64>::GenericNSSetMSyntheticFrontEnd(
 527     lldb::ValueObjectSP valobj_sp)
 528     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 529       m_data_32(nullptr), m_data_64(nullptr) {
 530   if (valobj_sp)
 531     Update();
 532 }
 533
 534 template <typename D32, typename D64>
 535 lldb_private::formatters::
 536   GenericNSSetMSyntheticFrontEnd<D32, D64>::~GenericNSSetMSyntheticFrontEnd() {
 537   delete m_data_32;
 538   m_data_32 = nullptr;
 539   delete m_data_64;
 540   m_data_64 = nullptr;
 541 }
 542
 543 template <typename D32, typename D64>
 544 size_t
 545 lldb_private::formatters::
 546   GenericNSSetMSyntheticFrontEnd<D32, D64>::GetIndexOfChildWithName(
 547     const ConstString &name) {
 548   const char *item_name = name.GetCString();
 549   uint32_t idx = ExtractIndexFromString(item_name);
 550   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 551     return UINT32_MAX;
 552   return idx;
 553 }
 554
 555 template <typename D32, typename D64>
 556 size_t
 557 lldb_private::formatters::
 558   GenericNSSetMSyntheticFrontEnd<D32, D64>::CalculateNumChildren() {
 559   if (!m_data_32 && !m_data_64)
 560     return 0;
 561   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 562 }
 563
 564 template <typename D32, typename D64>
 565 bool
 566 lldb_private::formatters::
 567   GenericNSSetMSyntheticFrontEnd<D32, D64>::Update() {
 568   m_children.clear();
 569   ValueObjectSP valobj_sp = m_backend.GetSP();
 570   m_ptr_size = 0;
 571   delete m_data_32;
 572   m_data_32 = nullptr;
 573   delete m_data_64;
 574   m_data_64 = nullptr;
 575   if (!valobj_sp)
 576     return false;
 577   if (!valobj_sp)
 578     return false;
 579   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 580   Status error;
 581   if (valobj_sp->IsPointerType()) {
 582     valobj_sp = valobj_sp->Dereference(error);
 583     if (error.Fail() || !valobj_sp)
 584       return false;
 585   }
 586   error.Clear();
 587   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 588   if (!process_sp)
 589     return false;
 590   m_ptr_size = process_sp->GetAddressByteSize();
 591   uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size;
 592   if (m_ptr_size == 4) {
 593     m_data_32 = new D32();
 594     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
 595                            error);
 596   } else {
 597     m_data_64 = new D64();
 598     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
 599                            error);
 600   }
 601   if (error.Fail())
 602     return false;
 603   return false;
 604 }
 605
 606 template <typename D32, typename D64>
 607 bool
 608 lldb_private::formatters::
 609   GenericNSSetMSyntheticFrontEnd<D32, D64>::MightHaveChildren() {
 610   return true;
 611 }
 612
 613 template <typename D32, typename D64>
 614 lldb::ValueObjectSP
 615 lldb_private::formatters::
 616   GenericNSSetMSyntheticFrontEnd<D32, D64>::GetChildAtIndex(size_t idx) {
 617   lldb::addr_t m_objs_addr =
 618       (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
 619
 620   uint32_t num_children = CalculateNumChildren();
 621
 622   if (idx >= num_children)
 623     return lldb::ValueObjectSP();
 624
 625   ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
 626   if (!process_sp)
 627     return lldb::ValueObjectSP();
 628
 629   if (m_children.empty()) {
 630     // do the scan phase
 631     lldb::addr_t obj_at_idx = 0;
 632
 633     uint32_t tries = 0;
 634     uint32_t test_idx = 0;
 635
 636     while (tries < num_children) {
 637       obj_at_idx = m_objs_addr + (test_idx * m_ptr_size);
 638       if (!process_sp)
 639         return lldb::ValueObjectSP();
 640       Status error;
 641       obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
 642       if (error.Fail())
 643         return lldb::ValueObjectSP();
 644
 645       test_idx++;
 646
 647       if (!obj_at_idx)
 648         continue;
 649       tries++;
 650
 651       SetItemDescriptor descriptor = {obj_at_idx, lldb::ValueObjectSP()};
 652
 653       m_children.push_back(descriptor);
 654     }
 655   }
 656
 657   if (idx >= m_children.size()) // should never happen
 658     return lldb::ValueObjectSP();
 659
 660   SetItemDescriptor &set_item = m_children[idx];
 661   if (!set_item.valobj_sp) {
 662     auto ptr_size = process_sp->GetAddressByteSize();
 663     DataBufferHeap buffer(ptr_size, 0);
 664     switch (ptr_size) {
 665     case 0: // architecture has no clue?? - fail
 666       return lldb::ValueObjectSP();
 667     case 4:
 668       *((uint32_t *)buffer.GetBytes()) = (uint32_t)set_item.item_ptr;
 669       break;
 670     case 8:
 671       *((uint64_t *)buffer.GetBytes()) = (uint64_t)set_item.item_ptr;
 672       break;
 673     default:
 674       assert(false && "pointer size is not 4 nor 8 - get out of here ASAP");
 675     }
 676     StreamString idx_name;
 677     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 678
 679     DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
 680                        process_sp->GetByteOrder(),
 681                        process_sp->GetAddressByteSize());
 682
 683     set_item.valobj_sp = CreateValueObjectFromData(
 684         idx_name.GetString(), data, m_exe_ctx_ref,
 685         m_backend.GetCompilerType().GetBasicTypeFromAST(
 686             lldb::eBasicTypeObjCID));
 687   }
 688   return set_item.valobj_sp;
 689 }
 690
 691 template bool lldb_private::formatters::NSSetSummaryProvider<true>(
 692     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
 693
 694 template bool lldb_private::formatters::NSSetSummaryProvider<false>(
 695     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);