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