source/Plugins/Language/ObjC/NSArray.cpp

   1 //===-- NSArray.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 "clang/AST/ASTContext.h"
  11
  12 #include "Cocoa.h"
  13
  14 #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/ObjCLanguageRuntime.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Utility/DataBufferHeap.h"
  24 #include "lldb/Utility/Endian.h"
  25 #include "lldb/Utility/Status.h"
  26 #include "lldb/Utility/Stream.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30 using namespace lldb_private::formatters;
  31
  32 namespace lldb_private {
  33 namespace formatters {
  34 std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
  35 NSArray_Additionals::GetAdditionalSummaries() {
  36   static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
  37   return g_map;
  38 }
  39
  40 std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> &
  41 NSArray_Additionals::GetAdditionalSynthetics() {
  42   static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>
  43       g_map;
  44   return g_map;
  45 }
  46
  47 class NSArrayMSyntheticFrontEndBase : public SyntheticChildrenFrontEnd {
  48 public:
  49   NSArrayMSyntheticFrontEndBase(lldb::ValueObjectSP valobj_sp);
  50
  51   ~NSArrayMSyntheticFrontEndBase() override = default;
  52
  53   size_t CalculateNumChildren() override;
  54
  55   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
  56
  57   bool Update() override = 0;
  58
  59   bool MightHaveChildren() override;
  60
  61   size_t GetIndexOfChildWithName(const ConstString &name) override;
  62
  63 protected:
  64   virtual lldb::addr_t GetDataAddress() = 0;
  65
  66   virtual uint64_t GetUsedCount() = 0;
  67
  68   virtual uint64_t GetOffset() = 0;
  69
  70   virtual uint64_t GetSize() = 0;
  71
  72   ExecutionContextRef m_exe_ctx_ref;
  73   uint8_t m_ptr_size;
  74   CompilerType m_id_type;
  75 };
  76
  77 template <typename D32, typename D64>
  78 class GenericNSArrayMSyntheticFrontEnd : public NSArrayMSyntheticFrontEndBase {
  79 public:
  80   GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
  81
  82   ~GenericNSArrayMSyntheticFrontEnd() override;
  83
  84   bool Update() override;
  85
  86 protected:
  87   lldb::addr_t GetDataAddress() override;
  88
  89   uint64_t GetUsedCount() override;
  90
  91   uint64_t GetOffset() override;
  92
  93   uint64_t GetSize() override;
  94
  95 private:
  96   D32 *m_data_32;
  97   D64 *m_data_64;
  98 };
  99
 100 namespace Foundation109 {
 101   struct DataDescriptor_32 {
 102     uint32_t _used;
 103     uint32_t _priv1 : 2;
 104     uint32_t _size : 30;
 105     uint32_t _priv2 : 2;
 106     uint32_t _offset : 30;
 107     uint32_t _priv3;
 108     uint32_t _data;
 109   };
 110
 111   struct DataDescriptor_64 {
 112     uint64_t _used;
 113     uint64_t _priv1 : 2;
 114     uint64_t _size : 62;
 115     uint64_t _priv2 : 2;
 116     uint64_t _offset : 62;
 117     uint32_t _priv3;
 118     uint64_t _data;
 119   };
 120
 121   using NSArrayMSyntheticFrontEnd =
 122       GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 123 }
 124
 125 namespace Foundation1010 {
 126   struct DataDescriptor_32 {
 127     uint32_t _used;
 128     uint32_t _offset;
 129     uint32_t _size : 28;
 130     uint64_t _priv1 : 4;
 131     uint32_t _priv2;
 132     uint32_t _data;
 133   };
 134
 135   struct DataDescriptor_64 {
 136     uint64_t _used;
 137     uint64_t _offset;
 138     uint64_t _size : 60;
 139     uint64_t _priv1 : 4;
 140     uint32_t _priv2;
 141     uint64_t _data;
 142   };
 143
 144   using NSArrayMSyntheticFrontEnd =
 145       GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 146 }
 147
 148 namespace Foundation1428 {
 149   struct DataDescriptor_32 {
 150     uint32_t _used;
 151     uint32_t _offset;
 152     uint32_t _size;
 153     uint32_t _data;
 154   };
 155
 156   struct DataDescriptor_64 {
 157     uint64_t _used;
 158     uint64_t _offset;
 159     uint64_t _size;
 160     uint64_t _data;
 161   };
 162
 163   using NSArrayMSyntheticFrontEnd =
 164       GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 165 }
 166
 167 namespace Foundation1437 {
 168   template <typename PtrType>
 169   struct DataDescriptor {
 170     PtrType _cow;
 171     // __deque
 172     PtrType _data;
 173     uint32_t _offset;
 174     uint32_t _size;
 175     union {
 176       PtrType _mutations;
 177       struct {
 178         uint32_t _muts;
 179         uint32_t _used;
 180       };
 181     };
 182   };
 183
 184   using NSArrayMSyntheticFrontEnd =
 185      GenericNSArrayMSyntheticFrontEnd<
 186         DataDescriptor<uint32_t>, DataDescriptor<uint64_t>>;
 187
 188   template <typename DD>
 189   uint64_t
 190   __NSArrayMSize_Impl(lldb_private::Process &process,
 191                       lldb::addr_t valobj_addr, Status &error) {
 192     const lldb::addr_t start_of_descriptor =
 193     valobj_addr + process.GetAddressByteSize();
 194     DD descriptor = DD();
 195     process.ReadMemory(start_of_descriptor, &descriptor,
 196                        sizeof(descriptor), error);
 197     if (error.Fail()) {
 198       return 0;
 199     }
 200     return descriptor._used;
 201   }
 202
 203   uint64_t
 204   __NSArrayMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
 205                  Status &error) {
 206     if (process.GetAddressByteSize() == 4) {
 207       return __NSArrayMSize_Impl<DataDescriptor<uint32_t>>(process, valobj_addr,
 208                                                            error);
 209     } else {
 210       return __NSArrayMSize_Impl<DataDescriptor<uint64_t>>(process, valobj_addr,
 211                                                            error);
 212     }
 213   }
 214
 215 }
 216
 217 namespace CallStackArray {
 218 struct DataDescriptor_32 {
 219   uint32_t _data;
 220   uint32_t _used;
 221   uint32_t _offset;
 222   const uint32_t _size = 0;
 223 };
 224
 225 struct DataDescriptor_64 {
 226   uint64_t _data;
 227   uint64_t _used;
 228   uint64_t _offset;
 229   const uint64_t _size = 0;
 230 };
 231
 232 using NSCallStackArraySyntheticFrontEnd =
 233     GenericNSArrayMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 234 } // namespace CallStackArray
 235
 236 template <typename D32, typename D64, bool Inline>
 237 class GenericNSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 238 public:
 239   GenericNSArrayISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 240
 241   ~GenericNSArrayISyntheticFrontEnd() override;
 242
 243   size_t CalculateNumChildren() override;
 244
 245   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 246
 247   bool Update() override;
 248
 249   bool MightHaveChildren() override;
 250
 251   size_t GetIndexOfChildWithName(const ConstString &name) override;
 252
 253 private:
 254   ExecutionContextRef m_exe_ctx_ref;
 255   uint8_t m_ptr_size;
 256
 257   D32 *m_data_32;
 258   D64 *m_data_64;
 259   CompilerType m_id_type;
 260 };
 261
 262 namespace Foundation1300 {
 263     struct IDD32 {
 264         uint32_t used;
 265         uint32_t list;
 266     };
 267
 268     struct IDD64 {
 269         uint64_t used;
 270         uint64_t list;
 271     };
 272
 273     using NSArrayISyntheticFrontEnd =
 274         GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, true>;
 275 }
 276
 277 namespace Foundation1430 {
 278     using NSArrayISyntheticFrontEnd =
 279         Foundation1428::NSArrayMSyntheticFrontEnd;
 280 }
 281
 282 namespace Foundation1436 {
 283     struct IDD32 {
 284         uint32_t used;
 285         uint32_t list; // in Inline cases, this is the first element
 286     };
 287
 288     struct IDD64 {
 289         uint64_t used;
 290         uint64_t list; // in Inline cases, this is the first element
 291     };
 292
 293     using NSArrayI_TransferSyntheticFrontEnd =
 294         GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, false>;
 295
 296     using NSArrayISyntheticFrontEnd =
 297         GenericNSArrayISyntheticFrontEnd<IDD32, IDD64, true>;
 298
 299     using NSFrozenArrayMSyntheticFrontEnd =
 300         Foundation1437::NSArrayMSyntheticFrontEnd;
 301
 302     uint64_t
 303     __NSFrozenArrayMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
 304                          Status &error) {
 305       return Foundation1437::__NSArrayMSize(process, valobj_addr, error);
 306     }
 307 }
 308
 309 class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 310 public:
 311   NSArray0SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 312
 313   ~NSArray0SyntheticFrontEnd() override = default;
 314
 315   size_t CalculateNumChildren() override;
 316
 317   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 318
 319   bool Update() override;
 320
 321   bool MightHaveChildren() override;
 322
 323   size_t GetIndexOfChildWithName(const ConstString &name) override;
 324 };
 325
 326 class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 327 public:
 328   NSArray1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 329
 330   ~NSArray1SyntheticFrontEnd() override = default;
 331
 332   size_t CalculateNumChildren() override;
 333
 334   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 335
 336   bool Update() override;
 337
 338   bool MightHaveChildren() override;
 339
 340   size_t GetIndexOfChildWithName(const ConstString &name) override;
 341 };
 342 } // namespace formatters
 343 } // namespace lldb_private
 344
 345 bool lldb_private::formatters::NSArraySummaryProvider(
 346     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 347   static ConstString g_TypeHint("NSArray");
 348
 349   ProcessSP process_sp = valobj.GetProcessSP();
 350   if (!process_sp)
 351     return false;
 352
 353   ObjCLanguageRuntime *runtime =
 354       (ObjCLanguageRuntime *)process_sp->GetLanguageRuntime(
 355           lldb::eLanguageTypeObjC);
 356
 357   if (!runtime)
 358     return false;
 359
 360   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 361       runtime->GetClassDescriptor(valobj));
 362
 363   if (!descriptor || !descriptor->IsValid())
 364     return false;
 365
 366   uint32_t ptr_size = process_sp->GetAddressByteSize();
 367
 368   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
 369
 370   if (!valobj_addr)
 371     return false;
 372
 373   uint64_t value = 0;
 374
 375   ConstString class_name(descriptor->GetClassName());
 376
 377   static const ConstString g_NSArrayI("__NSArrayI");
 378   static const ConstString g_NSArrayM("__NSArrayM");
 379   static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
 380   static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
 381   static const ConstString g_NSArray0("__NSArray0");
 382   static const ConstString g_NSArray1("__NSSingleObjectArrayI");
 383   static const ConstString g_NSArrayCF("__NSCFArray");
 384   static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
 385   static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
 386   static const ConstString g_NSCallStackArray("_NSCallStackArray");
 387
 388   if (class_name.IsEmpty())
 389     return false;
 390
 391   if (class_name == g_NSArrayI) {
 392     Status error;
 393     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 394                                                       ptr_size, 0, error);
 395     if (error.Fail())
 396       return false;
 397   } else if (class_name == g_NSArrayM) {
 398     AppleObjCRuntime *apple_runtime =
 399     llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
 400     Status error;
 401     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
 402       value = Foundation1437::__NSArrayMSize(*process_sp, valobj_addr, error);
 403     } else {
 404       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 405                                                         ptr_size, 0, error);
 406     }
 407     if (error.Fail())
 408       return false;
 409   } else if (class_name == g_NSArrayI_Transfer) {
 410     Status error;
 411     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 412                                                       ptr_size, 0, error);
 413     if (error.Fail())
 414       return false;
 415   } else if (class_name == g_NSFrozenArrayM) {
 416     Status error;
 417     value = Foundation1436::__NSFrozenArrayMSize(*process_sp, valobj_addr, error);
 418     if (error.Fail())
 419       return false;
 420   } else if (class_name == g_NSArrayMLegacy) {
 421     Status error;
 422     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 423                                                       ptr_size, 0, error);
 424     if (error.Fail())
 425       return false;
 426   } else if (class_name == g_NSArrayMImmutable) {
 427     Status error;
 428     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 429                                                       ptr_size, 0, error);
 430     if (error.Fail())
 431       return false;
 432   } else if (class_name == g_NSArray0) {
 433     value = 0;
 434   } else if (class_name == g_NSArray1) {
 435     value = 1;
 436   } else if (class_name == g_NSArrayCF || class_name == g_NSCallStackArray) {
 437     // __NSCFArray and _NSCallStackArray store the number of elements as a
 438     // pointer-sized value at offset `2 * ptr_size`.
 439     Status error;
 440     value = process_sp->ReadUnsignedIntegerFromMemory(
 441         valobj_addr + 2 * ptr_size, ptr_size, 0, error);
 442     if (error.Fail())
 443       return false;
 444   } else {
 445     auto &map(NSArray_Additionals::GetAdditionalSummaries());
 446     auto iter = map.find(class_name), end = map.end();
 447     if (iter != end)
 448       return iter->second(valobj, stream, options);
 449     else
 450       return false;
 451   }
 452
 453   std::string prefix, suffix;
 454   if (Language *language = Language::FindPlugin(options.GetLanguage())) {
 455     if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
 456                                             suffix)) {
 457       prefix.clear();
 458       suffix.clear();
 459     }
 460   }
 461
 462   stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
 463                 value == 1 ? "" : "s", suffix.c_str());
 464   return true;
 465 }
 466
 467 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::NSArrayMSyntheticFrontEndBase(
 468     lldb::ValueObjectSP valobj_sp)
 469     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 470       m_id_type() {
 471   if (valobj_sp) {
 472     clang::ASTContext *ast = valobj_sp->GetExecutionContextRef()
 473                                  .GetTargetSP()
 474                                  ->GetScratchClangASTContext()
 475                                  ->getASTContext();
 476     if (ast)
 477       m_id_type = CompilerType(ast, ast->ObjCBuiltinIdTy);
 478     if (valobj_sp->GetProcessSP())
 479       m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize();
 480   }
 481 }
 482
 483 template <typename D32, typename D64>
 484 lldb_private::formatters::
 485   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 486     GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 487     : NSArrayMSyntheticFrontEndBase(valobj_sp), m_data_32(nullptr),
 488       m_data_64(nullptr) {}
 489
 490 size_t
 491 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::CalculateNumChildren() {
 492   return GetUsedCount();
 493 }
 494
 495 lldb::ValueObjectSP
 496 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetChildAtIndex(
 497     size_t idx) {
 498   if (idx >= CalculateNumChildren())
 499     return lldb::ValueObjectSP();
 500   lldb::addr_t object_at_idx = GetDataAddress();
 501   size_t pyhs_idx = idx;
 502   pyhs_idx += GetOffset();
 503   if (GetSize() <= pyhs_idx)
 504     pyhs_idx -= GetSize();
 505   object_at_idx += (pyhs_idx * m_ptr_size);
 506   StreamString idx_name;
 507   idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 508   return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
 509                                       m_exe_ctx_ref, m_id_type);
 510 }
 511
 512 template <typename D32, typename D64>
 513 bool
 514 lldb_private::formatters::
 515   GenericNSArrayMSyntheticFrontEnd<D32, D64>::Update() {
 516   ValueObjectSP valobj_sp = m_backend.GetSP();
 517   m_ptr_size = 0;
 518   delete m_data_32;
 519   m_data_32 = nullptr;
 520   delete m_data_64;
 521   m_data_64 = nullptr;
 522   if (!valobj_sp)
 523     return false;
 524   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 525   Status error;
 526   error.Clear();
 527   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 528   if (!process_sp)
 529     return false;
 530   m_ptr_size = process_sp->GetAddressByteSize();
 531   uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
 532   if (m_ptr_size == 4) {
 533     m_data_32 = new D32();
 534     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
 535                            error);
 536   } else {
 537     m_data_64 = new D64();
 538     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
 539                            error);
 540   }
 541   if (error.Fail())
 542     return false;
 543   return false;
 544 }
 545
 546 bool
 547 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::MightHaveChildren() {
 548   return true;
 549 }
 550
 551 size_t
 552 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName(
 553     const ConstString &name) {
 554   const char *item_name = name.GetCString();
 555   uint32_t idx = ExtractIndexFromString(item_name);
 556   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 557     return UINT32_MAX;
 558   return idx;
 559 }
 560
 561 template <typename D32, typename D64>
 562 lldb_private::formatters::
 563   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 564     ~GenericNSArrayMSyntheticFrontEnd() {
 565   delete m_data_32;
 566   m_data_32 = nullptr;
 567   delete m_data_64;
 568   m_data_64 = nullptr;
 569 }
 570
 571 template <typename D32, typename D64>
 572 lldb::addr_t
 573 lldb_private::formatters::
 574   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 575     GenericNSArrayMSyntheticFrontEnd::GetDataAddress() {
 576   if (!m_data_32 && !m_data_64)
 577     return LLDB_INVALID_ADDRESS;
 578   return m_data_32 ? m_data_32->_data : m_data_64->_data;
 579 }
 580
 581 template <typename D32, typename D64>
 582 uint64_t
 583 lldb_private::formatters::
 584   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 585     GenericNSArrayMSyntheticFrontEnd::GetUsedCount() {
 586   if (!m_data_32 && !m_data_64)
 587     return 0;
 588   return m_data_32 ? m_data_32->_used : m_data_64->_used;
 589 }
 590
 591 template <typename D32, typename D64>
 592 uint64_t
 593 lldb_private::formatters::
 594   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 595     GenericNSArrayMSyntheticFrontEnd::GetOffset() {
 596   if (!m_data_32 && !m_data_64)
 597     return 0;
 598   return m_data_32 ? m_data_32->_offset : m_data_64->_offset;
 599 }
 600
 601 template <typename D32, typename D64>
 602 uint64_t
 603 lldb_private::formatters::
 604   GenericNSArrayMSyntheticFrontEnd<D32, D64>::
 605     GenericNSArrayMSyntheticFrontEnd::GetSize() {
 606   if (!m_data_32 && !m_data_64)
 607     return 0;
 608   return m_data_32 ? m_data_32->_size : m_data_64->_size;
 609 }
 610
 611 template <typename D32, typename D64, bool Inline>
 612 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 613   GenericNSArrayISyntheticFrontEnd(
 614     lldb::ValueObjectSP valobj_sp)
 615     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 616       m_data_32(nullptr), m_data_64(nullptr) {
 617   if (valobj_sp) {
 618     CompilerType type = valobj_sp->GetCompilerType();
 619     if (type) {
 620       ClangASTContext *ast = valobj_sp->GetExecutionContextRef()
 621                                  .GetTargetSP()
 622                                  ->GetScratchClangASTContext();
 623       if (ast)
 624         m_id_type = CompilerType(ast->getASTContext(),
 625                                  ast->getASTContext()->ObjCBuiltinIdTy);
 626     }
 627   }
 628 }
 629
 630 template <typename D32, typename D64, bool Inline>
 631 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 632   ~GenericNSArrayISyntheticFrontEnd() {
 633   delete m_data_32;
 634   m_data_32 = nullptr;
 635   delete m_data_64;
 636   m_data_64 = nullptr;
 637 }
 638
 639 template <typename D32, typename D64, bool Inline>
 640 size_t
 641 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 642   GetIndexOfChildWithName(const ConstString &name) {
 643   const char *item_name = name.GetCString();
 644   uint32_t idx = ExtractIndexFromString(item_name);
 645   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 646     return UINT32_MAX;
 647   return idx;
 648 }
 649
 650 template <typename D32, typename D64, bool Inline>
 651 size_t
 652 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 653   CalculateNumChildren() {
 654   return m_data_32 ? m_data_32->used : m_data_64->used;
 655 }
 656
 657 template <typename D32, typename D64, bool Inline>
 658 bool
 659 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 660   Update() {
 661   ValueObjectSP valobj_sp = m_backend.GetSP();
 662   m_ptr_size = 0;
 663   delete m_data_32;
 664   m_data_32 = nullptr;
 665   delete m_data_64;
 666   m_data_64 = nullptr;
 667   if (!valobj_sp)
 668     return false;
 669   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 670   Status error;
 671   error.Clear();
 672   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 673   if (!process_sp)
 674     return false;
 675   m_ptr_size = process_sp->GetAddressByteSize();
 676   uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
 677   if (m_ptr_size == 4) {
 678     m_data_32 = new D32();
 679     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
 680                            error);
 681   } else {
 682     m_data_64 = new D64();
 683     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
 684                            error);
 685   }
 686   if (error.Fail())
 687     return false;
 688   return false;
 689 }
 690
 691 template <typename D32, typename D64, bool Inline>
 692 bool
 693 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 694   MightHaveChildren() {
 695   return true;
 696 }
 697
 698 template <typename D32, typename D64, bool Inline>
 699 lldb::ValueObjectSP
 700 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
 701   GetChildAtIndex(size_t idx) {
 702   if (idx >= CalculateNumChildren())
 703     return lldb::ValueObjectSP();
 704   lldb::addr_t object_at_idx;
 705   if (Inline) {
 706     object_at_idx = m_backend.GetSP()->GetValueAsUnsigned(0) + m_ptr_size;
 707     object_at_idx += m_ptr_size == 4 ? sizeof(D32) : sizeof(D64); // skip the data header
 708     object_at_idx -= m_ptr_size; // we treat the last entry in the data header as the first pointer
 709   } else {
 710     object_at_idx = m_data_32 ? m_data_32->list : m_data_64->list;
 711   }
 712   object_at_idx += (idx * m_ptr_size);
 713
 714   ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
 715   if (!process_sp)
 716     return lldb::ValueObjectSP();
 717   Status error;
 718   if (error.Fail())
 719     return lldb::ValueObjectSP();
 720   StreamString idx_name;
 721   idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 722   return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
 723                                       m_exe_ctx_ref, m_id_type);
 724 }
 725
 726 lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd(
 727     lldb::ValueObjectSP valobj_sp)
 728     : SyntheticChildrenFrontEnd(*valobj_sp) {}
 729
 730 size_t
 731 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName(
 732     const ConstString &name) {
 733   return UINT32_MAX;
 734 }
 735
 736 size_t
 737 lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren() {
 738   return 0;
 739 }
 740
 741 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::Update() {
 742   return false;
 743 }
 744
 745 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::MightHaveChildren() {
 746   return false;
 747 }
 748
 749 lldb::ValueObjectSP
 750 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetChildAtIndex(
 751     size_t idx) {
 752   return lldb::ValueObjectSP();
 753 }
 754
 755 lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd(
 756     lldb::ValueObjectSP valobj_sp)
 757     : SyntheticChildrenFrontEnd(*valobj_sp.get()) {}
 758
 759 size_t
 760 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName(
 761     const ConstString &name) {
 762   static const ConstString g_zero("[0]");
 763
 764   if (name == g_zero)
 765     return 0;
 766
 767   return UINT32_MAX;
 768 }
 769
 770 size_t
 771 lldb_private::formatters::NSArray1SyntheticFrontEnd::CalculateNumChildren() {
 772   return 1;
 773 }
 774
 775 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::Update() {
 776   return false;
 777 }
 778
 779 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::MightHaveChildren() {
 780   return true;
 781 }
 782
 783 lldb::ValueObjectSP
 784 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetChildAtIndex(
 785     size_t idx) {
 786   static const ConstString g_zero("[0]");
 787
 788   if (idx == 0) {
 789     CompilerType id_type(
 790         m_backend.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(
 791             lldb::eBasicTypeObjCID));
 792     return m_backend.GetSyntheticChildAtOffset(
 793         m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true, g_zero);
 794   }
 795   return lldb::ValueObjectSP();
 796 }
 797
 798 SyntheticChildrenFrontEnd *
 799 lldb_private::formatters::NSArraySyntheticFrontEndCreator(
 800     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
 801   if (!valobj_sp)
 802     return nullptr;
 803
 804   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 805   if (!process_sp)
 806     return nullptr;
 807   AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
 808       process_sp->GetObjCLanguageRuntime());
 809   if (!runtime)
 810     return nullptr;
 811
 812   CompilerType valobj_type(valobj_sp->GetCompilerType());
 813   Flags flags(valobj_type.GetTypeInfo());
 814
 815   if (flags.IsClear(eTypeIsPointer)) {
 816     Status error;
 817     valobj_sp = valobj_sp->AddressOf(error);
 818     if (error.Fail() || !valobj_sp)
 819       return nullptr;
 820   }
 821
 822   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 823       runtime->GetClassDescriptor(*valobj_sp));
 824
 825   if (!descriptor || !descriptor->IsValid())
 826     return nullptr;
 827
 828   ConstString class_name(descriptor->GetClassName());
 829
 830   static const ConstString g_NSArrayI("__NSArrayI");
 831   static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
 832   static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
 833   static const ConstString g_NSArrayM("__NSArrayM");
 834   static const ConstString g_NSArray0("__NSArray0");
 835   static const ConstString g_NSArray1("__NSSingleObjectArrayI");
 836   static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
 837   static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
 838   static const ConstString g_NSCallStackArray("_NSCallStackArray");
 839
 840   if (class_name.IsEmpty())
 841     return nullptr;
 842
 843   if (class_name == g_NSArrayI) {
 844     if (runtime->GetFoundationVersion() >= 1436)
 845       return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp));
 846     if (runtime->GetFoundationVersion() >= 1430)
 847       return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp));
 848     else
 849       return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp));
 850   } else if (class_name == g_NSArrayI_Transfer) {
 851       return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp));
 852   } else if (class_name == g_NSArray0) {
 853   } else if (class_name == g_NSFrozenArrayM) {
 854     return (new Foundation1436::NSFrozenArrayMSyntheticFrontEnd(valobj_sp));
 855   } else if (class_name == g_NSArray0) {
 856     return (new NSArray0SyntheticFrontEnd(valobj_sp));
 857   } else if (class_name == g_NSArray1) {
 858     return (new NSArray1SyntheticFrontEnd(valobj_sp));
 859   } else if (class_name == g_NSArrayM) {
 860     if (runtime->GetFoundationVersion() >= 1437)
 861       return (new Foundation1437::NSArrayMSyntheticFrontEnd(valobj_sp));
 862     if (runtime->GetFoundationVersion() >= 1428)
 863       return (new Foundation1428::NSArrayMSyntheticFrontEnd(valobj_sp));
 864     if (runtime->GetFoundationVersion() >= 1100)
 865       return (new Foundation1010::NSArrayMSyntheticFrontEnd(valobj_sp));
 866     else
 867       return (new Foundation109::NSArrayMSyntheticFrontEnd(valobj_sp));
 868   } else if (class_name == g_NSCallStackArray) {
 869     return (new CallStackArray::NSCallStackArraySyntheticFrontEnd(valobj_sp));
 870   } else {
 871     auto &map(NSArray_Additionals::GetAdditionalSynthetics());
 872     auto iter = map.find(class_name), end = map.end();
 873     if (iter != end)
 874       return iter->second(synth, valobj_sp);
 875   }
 876
 877   return nullptr;
 878 }