1 //===-- NSArray.cpp ---------------------------------------------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #include "clang/AST/ASTContext.h"
13 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
15 #include "lldb/Core/ValueObject.h"
16 #include "lldb/Core/ValueObjectConstResult.h"
17 #include "lldb/DataFormatters/FormattersHelpers.h"
18 #include "lldb/Expression/FunctionCaller.h"
19 #include "lldb/Symbol/ClangASTContext.h"
20 #include "lldb/Target/Language.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/DataBufferHeap.h"
23 #include "lldb/Utility/Endian.h"
24 #include "lldb/Utility/Status.h"
25 #include "lldb/Utility/Stream.h"
28 using namespace lldb_private;
29 using namespace lldb_private::formatters;
31 namespace lldb_private {
32 namespace formatters {
33 std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
34 NSArray_Additionals::GetAdditionalSummaries() {
35 static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
39 std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> &
40 NSArray_Additionals::GetAdditionalSynthetics() {
41 static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>
46 class NSArrayMSyntheticFrontEndBase : public SyntheticChildrenFrontEnd {
48 NSArrayMSyntheticFrontEndBase(lldb::ValueObjectSP valobj_sp);
50 ~NSArrayMSyntheticFrontEndBase() override = default;
52 size_t CalculateNumChildren() override;
54 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
56 bool Update() override = 0;
58 bool MightHaveChildren() override;
60 size_t GetIndexOfChildWithName(ConstString name) override;
63 virtual lldb::addr_t GetDataAddress() = 0;
65 virtual uint64_t GetUsedCount() = 0;
67 virtual uint64_t GetOffset() = 0;
69 virtual uint64_t GetSize() = 0;
71 ExecutionContextRef m_exe_ctx_ref;
73 CompilerType m_id_type;
76 template <typename D32, typename D64>
77 class GenericNSArrayMSyntheticFrontEnd : public NSArrayMSyntheticFrontEndBase {
79 GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
81 ~GenericNSArrayMSyntheticFrontEnd() override;
83 bool Update() override;
86 lldb::addr_t GetDataAddress() override;
88 uint64_t GetUsedCount() override;
90 uint64_t GetOffset() override;
92 uint64_t GetSize() override;
99 namespace Foundation109 {
100 struct DataDescriptor_32 {
105 uint32_t _offset : 30;
110 struct DataDescriptor_64 {
115 uint64_t _offset : 62;
120 using NSArrayMSyntheticFrontEnd =
121 GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
124 namespace Foundation1010 {
125 struct DataDescriptor_32 {
134 struct DataDescriptor_64 {
143 using NSArrayMSyntheticFrontEnd =
144 GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
147 namespace Foundation1428 {
148 struct DataDescriptor_32 {
155 struct DataDescriptor_64 {
162 using NSArrayMSyntheticFrontEnd =
163 GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
166 namespace Foundation1437 {
167 template <typename PtrType>
168 struct DataDescriptor {
178 using NSArrayMSyntheticFrontEnd =
179 GenericNSArrayMSyntheticFrontEnd<
180 DataDescriptor<uint32_t>, DataDescriptor<uint64_t>>;
182 template <typename DD>
184 __NSArrayMSize_Impl(lldb_private::Process &process,
185 lldb::addr_t valobj_addr, Status &error) {
186 const lldb::addr_t start_of_descriptor =
187 valobj_addr + process.GetAddressByteSize();
188 DD descriptor = DD();
189 process.ReadMemory(start_of_descriptor, &descriptor,
190 sizeof(descriptor), error);
194 return descriptor._used;
198 __NSArrayMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
200 if (process.GetAddressByteSize() == 4) {
201 return __NSArrayMSize_Impl<DataDescriptor<uint32_t>>(process, valobj_addr,
204 return __NSArrayMSize_Impl<DataDescriptor<uint64_t>>(process, valobj_addr,
211 namespace CallStackArray {
212 struct DataDescriptor_32 {
216 const uint32_t _size = 0;
219 struct DataDescriptor_64 {
223 const uint64_t _size = 0;
226 using NSCallStackArraySyntheticFrontEnd =
227 GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
228 } // namespace CallStackArray
230 template <typename D32, typename D64, bool Inline>
231 class GenericNSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd {
233 GenericNSArrayISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
235 ~GenericNSArrayISyntheticFrontEnd() override;
237 size_t CalculateNumChildren() override;
239 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
241 bool Update() override;
243 bool MightHaveChildren() override;
245 size_t GetIndexOfChildWithName(ConstString name) override;
248 ExecutionContextRef m_exe_ctx_ref;
253 CompilerType m_id_type;
256 namespace Foundation1300 {
267 using NSArrayISyntheticFrontEnd =
268 GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, true>;
271 namespace Foundation1430 {
272 using NSArrayISyntheticFrontEnd =
273 Foundation1428::NSArrayMSyntheticFrontEnd;
276 namespace Foundation1436 {
279 uint32_t list; // in Inline cases, this is the first element
284 uint64_t list; // in Inline cases, this is the first element
287 using NSArrayI_TransferSyntheticFrontEnd =
288 GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, false>;
290 using NSArrayISyntheticFrontEnd =
291 GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, true>;
293 using NSFrozenArrayMSyntheticFrontEnd =
294 Foundation1437::NSArrayMSyntheticFrontEnd;
297 __NSFrozenArrayMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
299 return Foundation1437::__NSArrayMSize(process, valobj_addr, error);
303 class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
305 NSArray0SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
307 ~NSArray0SyntheticFrontEnd() override = default;
309 size_t CalculateNumChildren() override;
311 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
313 bool Update() override;
315 bool MightHaveChildren() override;
317 size_t GetIndexOfChildWithName(ConstString name) override;
320 class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
322 NSArray1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
324 ~NSArray1SyntheticFrontEnd() override = default;
326 size_t CalculateNumChildren() override;
328 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
330 bool Update() override;
332 bool MightHaveChildren() override;
334 size_t GetIndexOfChildWithName(ConstString name) override;
336 } // namespace formatters
337 } // namespace lldb_private
339 bool lldb_private::formatters::NSArraySummaryProvider(
340 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
341 static ConstString g_TypeHint("NSArray");
343 ProcessSP process_sp = valobj.GetProcessSP();
347 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
352 ObjCLanguageRuntime::ClassDescriptorSP descriptor(
353 runtime->GetClassDescriptor(valobj));
355 if (!descriptor || !descriptor->IsValid())
358 uint32_t ptr_size = process_sp->GetAddressByteSize();
360 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
367 ConstString class_name(descriptor->GetClassName());
369 static const ConstString g_NSArrayI("__NSArrayI");
370 static const ConstString g_NSArrayM("__NSArrayM");
371 static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
372 static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
373 static const ConstString g_NSArray0("__NSArray0");
374 static const ConstString g_NSArray1("__NSSingleObjectArrayI");
375 static const ConstString g_NSArrayCF("__NSCFArray");
376 static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
377 static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
378 static const ConstString g_NSCallStackArray("_NSCallStackArray");
380 if (class_name.IsEmpty())
383 if (class_name == g_NSArrayI) {
385 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
389 } else if (class_name == g_NSArrayM) {
390 AppleObjCRuntime *apple_runtime =
391 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
393 if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
394 value = Foundation1437::__NSArrayMSize(*process_sp, valobj_addr, error);
396 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
401 } else if (class_name == g_NSArrayI_Transfer) {
403 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
407 } else if (class_name == g_NSFrozenArrayM) {
409 value = Foundation1436::__NSFrozenArrayMSize(*process_sp, valobj_addr, error);
412 } else if (class_name == g_NSArrayMLegacy) {
414 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
418 } else if (class_name == g_NSArrayMImmutable) {
420 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
424 } else if (class_name == g_NSArray0) {
426 } else if (class_name == g_NSArray1) {
428 } else if (class_name == g_NSArrayCF || class_name == g_NSCallStackArray) {
429 // __NSCFArray and _NSCallStackArray store the number of elements as a
430 // pointer-sized value at offset `2 * ptr_size`.
432 value = process_sp->ReadUnsignedIntegerFromMemory(
433 valobj_addr + 2 * ptr_size, ptr_size, 0, error);
437 auto &map(NSArray_Additionals::GetAdditionalSummaries());
438 auto iter = map.find(class_name), end = map.end();
440 return iter->second(valobj, stream, options);
445 std::string prefix, suffix;
446 if (Language *language = Language::FindPlugin(options.GetLanguage())) {
447 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
454 stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
455 value == 1 ? "" : "s", suffix.c_str());
459 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::NSArrayMSyntheticFrontEndBase(
460 lldb::ValueObjectSP valobj_sp)
461 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
464 clang::ASTContext *ast = valobj_sp->GetExecutionContextRef()
466 ->GetScratchClangASTContext()
469 m_id_type = CompilerType(ast, ast->ObjCBuiltinIdTy);
470 if (valobj_sp->GetProcessSP())
471 m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize();
475 template <typename D32, typename D64>
476 lldb_private::formatters::
477 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
478 GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
479 : NSArrayMSyntheticFrontEndBase(valobj_sp), m_data_32(nullptr),
480 m_data_64(nullptr) {}
483 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::CalculateNumChildren() {
484 return GetUsedCount();
488 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetChildAtIndex(
490 if (idx >= CalculateNumChildren())
491 return lldb::ValueObjectSP();
492 lldb::addr_t object_at_idx = GetDataAddress();
493 size_t pyhs_idx = idx;
494 pyhs_idx += GetOffset();
495 if (GetSize() <= pyhs_idx)
496 pyhs_idx -= GetSize();
497 object_at_idx += (pyhs_idx * m_ptr_size);
498 StreamString idx_name;
499 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
500 return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
501 m_exe_ctx_ref, m_id_type);
504 template <typename D32, typename D64>
506 lldb_private::formatters::
507 GenericNSArrayMSyntheticFrontEnd<D32, D64>::Update() {
508 ValueObjectSP valobj_sp = m_backend.GetSP();
516 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
519 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
522 m_ptr_size = process_sp->GetAddressByteSize();
523 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
524 if (m_ptr_size == 4) {
525 m_data_32 = new D32();
526 process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
529 m_data_64 = new D64();
530 process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
539 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::MightHaveChildren() {
544 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName(
546 const char *item_name = name.GetCString();
547 uint32_t idx = ExtractIndexFromString(item_name);
548 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
553 template <typename D32, typename D64>
554 lldb_private::formatters::
555 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
556 ~GenericNSArrayMSyntheticFrontEnd() {
563 template <typename D32, typename D64>
565 lldb_private::formatters::
566 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
567 GenericNSArrayMSyntheticFrontEnd::GetDataAddress() {
568 if (!m_data_32 && !m_data_64)
569 return LLDB_INVALID_ADDRESS;
570 return m_data_32 ? m_data_32->_data : m_data_64->_data;
573 template <typename D32, typename D64>
575 lldb_private::formatters::
576 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
577 GenericNSArrayMSyntheticFrontEnd::GetUsedCount() {
578 if (!m_data_32 && !m_data_64)
580 return m_data_32 ? m_data_32->_used : m_data_64->_used;
583 template <typename D32, typename D64>
585 lldb_private::formatters::
586 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
587 GenericNSArrayMSyntheticFrontEnd::GetOffset() {
588 if (!m_data_32 && !m_data_64)
590 return m_data_32 ? m_data_32->_offset : m_data_64->_offset;
593 template <typename D32, typename D64>
595 lldb_private::formatters::
596 GenericNSArrayMSyntheticFrontEnd<D32, D64>::
597 GenericNSArrayMSyntheticFrontEnd::GetSize() {
598 if (!m_data_32 && !m_data_64)
600 return m_data_32 ? m_data_32->_size : m_data_64->_size;
603 template <typename D32, typename D64, bool Inline>
604 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
605 GenericNSArrayISyntheticFrontEnd(
606 lldb::ValueObjectSP valobj_sp)
607 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
608 m_data_32(nullptr), m_data_64(nullptr) {
610 CompilerType type = valobj_sp->GetCompilerType();
612 ClangASTContext *ast = valobj_sp->GetExecutionContextRef()
614 ->GetScratchClangASTContext();
616 m_id_type = CompilerType(ast->getASTContext(),
617 ast->getASTContext()->ObjCBuiltinIdTy);
622 template <typename D32, typename D64, bool Inline>
623 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
624 ~GenericNSArrayISyntheticFrontEnd() {
631 template <typename D32, typename D64, bool Inline>
633 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
634 GetIndexOfChildWithName(ConstString name) {
635 const char *item_name = name.GetCString();
636 uint32_t idx = ExtractIndexFromString(item_name);
637 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
642 template <typename D32, typename D64, bool Inline>
644 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
645 CalculateNumChildren() {
646 return m_data_32 ? m_data_32->used : m_data_64->used;
649 template <typename D32, typename D64, bool Inline>
651 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
653 ValueObjectSP valobj_sp = m_backend.GetSP();
661 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
664 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
667 m_ptr_size = process_sp->GetAddressByteSize();
668 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
669 if (m_ptr_size == 4) {
670 m_data_32 = new D32();
671 process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
674 m_data_64 = new D64();
675 process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
683 template <typename D32, typename D64, bool Inline>
685 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
686 MightHaveChildren() {
690 template <typename D32, typename D64, bool Inline>
692 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
693 GetChildAtIndex(size_t idx) {
694 if (idx >= CalculateNumChildren())
695 return lldb::ValueObjectSP();
696 lldb::addr_t object_at_idx;
698 object_at_idx = m_backend.GetSP()->GetValueAsUnsigned(0) + m_ptr_size;
699 object_at_idx += m_ptr_size == 4 ? sizeof(D32) : sizeof(D64); // skip the data header
700 object_at_idx -= m_ptr_size; // we treat the last entry in the data header as the first pointer
702 object_at_idx = m_data_32 ? m_data_32->list : m_data_64->list;
704 object_at_idx += (idx * m_ptr_size);
706 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
708 return lldb::ValueObjectSP();
711 return lldb::ValueObjectSP();
712 StreamString idx_name;
713 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
714 return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
715 m_exe_ctx_ref, m_id_type);
718 lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd(
719 lldb::ValueObjectSP valobj_sp)
720 : SyntheticChildrenFrontEnd(*valobj_sp) {}
723 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName(
729 lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren() {
733 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::Update() {
737 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::MightHaveChildren() {
742 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetChildAtIndex(
744 return lldb::ValueObjectSP();
747 lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd(
748 lldb::ValueObjectSP valobj_sp)
749 : SyntheticChildrenFrontEnd(*valobj_sp.get()) {}
752 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName(
754 static const ConstString g_zero("[0]");
763 lldb_private::formatters::NSArray1SyntheticFrontEnd::CalculateNumChildren() {
767 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::Update() {
771 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::MightHaveChildren() {
776 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetChildAtIndex(
778 static const ConstString g_zero("[0]");
781 CompilerType id_type(
782 m_backend.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(
783 lldb::eBasicTypeObjCID));
784 return m_backend.GetSyntheticChildAtOffset(
785 m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true, g_zero);
787 return lldb::ValueObjectSP();
790 SyntheticChildrenFrontEnd *
791 lldb_private::formatters::NSArraySyntheticFrontEndCreator(
792 CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
796 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
799 AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
800 ObjCLanguageRuntime::Get(*process_sp));
804 CompilerType valobj_type(valobj_sp->GetCompilerType());
805 Flags flags(valobj_type.GetTypeInfo());
807 if (flags.IsClear(eTypeIsPointer)) {
809 valobj_sp = valobj_sp->AddressOf(error);
810 if (error.Fail() || !valobj_sp)
814 ObjCLanguageRuntime::ClassDescriptorSP descriptor(
815 runtime->GetClassDescriptor(*valobj_sp));
817 if (!descriptor || !descriptor->IsValid())
820 ConstString class_name(descriptor->GetClassName());
822 static const ConstString g_NSArrayI("__NSArrayI");
823 static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
824 static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
825 static const ConstString g_NSArrayM("__NSArrayM");
826 static const ConstString g_NSArray0("__NSArray0");
827 static const ConstString g_NSArray1("__NSSingleObjectArrayI");
828 static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
829 static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
830 static const ConstString g_NSCallStackArray("_NSCallStackArray");
832 if (class_name.IsEmpty())
835 if (class_name == g_NSArrayI) {
836 if (runtime->GetFoundationVersion() >= 1436)
837 return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp));
838 if (runtime->GetFoundationVersion() >= 1430)
839 return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp));
841 return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp));
842 } else if (class_name == g_NSArrayI_Transfer) {
843 return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp));
844 } else if (class_name == g_NSArray0) {
845 } else if (class_name == g_NSFrozenArrayM) {
846 return (new Foundation1436::NSFrozenArrayMSyntheticFrontEnd(valobj_sp));
847 } else if (class_name == g_NSArray0) {
848 return (new NSArray0SyntheticFrontEnd(valobj_sp));
849 } else if (class_name == g_NSArray1) {
850 return (new NSArray1SyntheticFrontEnd(valobj_sp));
851 } else if (class_name == g_NSArrayM) {
852 if (runtime->GetFoundationVersion() >= 1437)
853 return (new Foundation1437::NSArrayMSyntheticFrontEnd(valobj_sp));
854 if (runtime->GetFoundationVersion() >= 1428)
855 return (new Foundation1428::NSArrayMSyntheticFrontEnd(valobj_sp));
856 if (runtime->GetFoundationVersion() >= 1100)
857 return (new Foundation1010::NSArrayMSyntheticFrontEnd(valobj_sp));
859 return (new Foundation109::NSArrayMSyntheticFrontEnd(valobj_sp));
860 } else if (class_name == g_NSCallStackArray) {
861 return (new CallStackArray::NSCallStackArraySyntheticFrontEnd(valobj_sp));
863 auto &map(NSArray_Additionals::GetAdditionalSynthetics());
864 auto iter = map.find(class_name), end = map.end();
866 return iter->second(synth, valobj_sp);