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