contrib/llvm-project/lldb/source/Plugins/Language/ObjC/NSArray.cpp

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