contrib/llvm/tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

   1 //===-- NSDictionary.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 #include <mutex>
  13
  14 // Other libraries and framework includes
  15 #include "clang/AST/DeclCXX.h"
  16
  17 // Project includes
  18 #include "NSDictionary.h"
  19
  20 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
  21
  22 #include "lldb/Core/ValueObject.h"
  23 #include "lldb/Core/ValueObjectConstResult.h"
  24 #include "lldb/DataFormatters/FormattersHelpers.h"
  25 #include "lldb/Symbol/ClangASTContext.h"
  26 #include "lldb/Target/Language.h"
  27 #include "lldb/Target/ObjCLanguageRuntime.h"
  28 #include "lldb/Target/StackFrame.h"
  29 #include "lldb/Target/Target.h"
  30 #include "lldb/Utility/DataBufferHeap.h"
  31 #include "lldb/Utility/Endian.h"
  32 #include "lldb/Utility/Status.h"
  33 #include "lldb/Utility/Stream.h"
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37 using namespace lldb_private::formatters;
  38
  39 NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Prefix(
  40     ConstString p)
  41     : m_prefix(p) {}
  42
  43 bool NSDictionary_Additionals::AdditionalFormatterMatching::Prefix::Match(
  44     ConstString class_name) {
  45   return class_name.GetStringRef().startswith(m_prefix.GetStringRef());
  46 }
  47
  48 NSDictionary_Additionals::AdditionalFormatterMatching::Full::Full(ConstString n)
  49     : m_name(n) {}
  50
  51 bool NSDictionary_Additionals::AdditionalFormatterMatching::Full::Match(
  52     ConstString class_name) {
  53   return (class_name == m_name);
  54 }
  55
  56 NSDictionary_Additionals::AdditionalFormatters<
  57     CXXFunctionSummaryFormat::Callback> &
  58 NSDictionary_Additionals::GetAdditionalSummaries() {
  59   static AdditionalFormatters<CXXFunctionSummaryFormat::Callback> g_map;
  60   return g_map;
  61 }
  62
  63 NSDictionary_Additionals::AdditionalFormatters<
  64     CXXSyntheticChildren::CreateFrontEndCallback> &
  65 NSDictionary_Additionals::GetAdditionalSynthetics() {
  66   static AdditionalFormatters<CXXSyntheticChildren::CreateFrontEndCallback>
  67       g_map;
  68   return g_map;
  69 }
  70
  71 static CompilerType GetLLDBNSPairType(TargetSP target_sp) {
  72   CompilerType compiler_type;
  73
  74   ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext();
  75
  76   if (target_ast_context) {
  77     ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair");
  78
  79     compiler_type =
  80         target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(
  81             g___lldb_autogen_nspair);
  82
  83     if (!compiler_type) {
  84       compiler_type = target_ast_context->CreateRecordType(
  85           nullptr, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(),
  86           clang::TTK_Struct, lldb::eLanguageTypeC);
  87
  88       if (compiler_type) {
  89         ClangASTContext::StartTagDeclarationDefinition(compiler_type);
  90         CompilerType id_compiler_type =
  91             target_ast_context->GetBasicType(eBasicTypeObjCID);
  92         ClangASTContext::AddFieldToRecordType(
  93             compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);
  94         ClangASTContext::AddFieldToRecordType(
  95             compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0);
  96         ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
  97       }
  98     }
  99   }
 100   return compiler_type;
 101 }
 102
 103 namespace lldb_private {
 104 namespace formatters {
 105 class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 106 public:
 107   NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 108
 109   ~NSDictionaryISyntheticFrontEnd() override;
 110
 111   size_t CalculateNumChildren() override;
 112
 113   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 114
 115   bool Update() override;
 116
 117   bool MightHaveChildren() override;
 118
 119   size_t GetIndexOfChildWithName(const ConstString &name) override;
 120
 121 private:
 122   struct DataDescriptor_32 {
 123     uint32_t _used : 26;
 124     uint32_t _szidx : 6;
 125   };
 126
 127   struct DataDescriptor_64 {
 128     uint64_t _used : 58;
 129     uint32_t _szidx : 6;
 130   };
 131
 132   struct DictionaryItemDescriptor {
 133     lldb::addr_t key_ptr;
 134     lldb::addr_t val_ptr;
 135     lldb::ValueObjectSP valobj_sp;
 136   };
 137
 138   ExecutionContextRef m_exe_ctx_ref;
 139   uint8_t m_ptr_size;
 140   lldb::ByteOrder m_order;
 141   DataDescriptor_32 *m_data_32;
 142   DataDescriptor_64 *m_data_64;
 143   lldb::addr_t m_data_ptr;
 144   CompilerType m_pair_type;
 145   std::vector<DictionaryItemDescriptor> m_children;
 146 };
 147
 148 class NSDictionary1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 149 public:
 150   NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 151
 152   ~NSDictionary1SyntheticFrontEnd() override = default;
 153
 154   size_t CalculateNumChildren() override;
 155
 156   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 157
 158   bool Update() override;
 159
 160   bool MightHaveChildren() override;
 161
 162   size_t GetIndexOfChildWithName(const ConstString &name) override;
 163
 164 private:
 165   ValueObjectSP m_pair;
 166 };
 167
 168 template <typename D32, typename D64>
 169 class GenericNSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 170 public:
 171   GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 172
 173   ~GenericNSDictionaryMSyntheticFrontEnd() override;
 174
 175   size_t CalculateNumChildren() override;
 176
 177   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 178
 179   bool Update() override;
 180
 181   bool MightHaveChildren() override;
 182
 183   size_t GetIndexOfChildWithName(const ConstString &name) override;
 184
 185 private:
 186   struct DictionaryItemDescriptor {
 187     lldb::addr_t key_ptr;
 188     lldb::addr_t val_ptr;
 189     lldb::ValueObjectSP valobj_sp;
 190   };
 191
 192   ExecutionContextRef m_exe_ctx_ref;
 193   uint8_t m_ptr_size;
 194   lldb::ByteOrder m_order;
 195   D32 *m_data_32;
 196   D64 *m_data_64;
 197   CompilerType m_pair_type;
 198   std::vector<DictionaryItemDescriptor> m_children;
 199 };
 200
 201 namespace Foundation1100 {
 202   class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 203   public:
 204     NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 205
 206     ~NSDictionaryMSyntheticFrontEnd() override;
 207
 208     size_t CalculateNumChildren() override;
 209
 210     lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 211
 212     bool Update() override;
 213
 214     bool MightHaveChildren() override;
 215
 216     size_t GetIndexOfChildWithName(const ConstString &name) override;
 217
 218   private:
 219     struct DataDescriptor_32 {
 220       uint32_t _used : 26;
 221       uint32_t _kvo : 1;
 222       uint32_t _size;
 223       uint32_t _mutations;
 224       uint32_t _objs_addr;
 225       uint32_t _keys_addr;
 226     };
 227
 228     struct DataDescriptor_64 {
 229       uint64_t _used : 58;
 230       uint32_t _kvo : 1;
 231       uint64_t _size;
 232       uint64_t _mutations;
 233       uint64_t _objs_addr;
 234       uint64_t _keys_addr;
 235     };
 236
 237     struct DictionaryItemDescriptor {
 238       lldb::addr_t key_ptr;
 239       lldb::addr_t val_ptr;
 240       lldb::ValueObjectSP valobj_sp;
 241     };
 242
 243     ExecutionContextRef m_exe_ctx_ref;
 244     uint8_t m_ptr_size;
 245     lldb::ByteOrder m_order;
 246     DataDescriptor_32 *m_data_32;
 247     DataDescriptor_64 *m_data_64;
 248     CompilerType m_pair_type;
 249     std::vector<DictionaryItemDescriptor> m_children;
 250   };
 251 }
 252
 253 namespace Foundation1428 {
 254   struct DataDescriptor_32 {
 255     uint32_t _used : 26;
 256     uint32_t _kvo : 1;
 257     uint32_t _size;
 258     uint32_t _buffer;
 259     uint64_t GetSize() { return _size; }
 260   };
 261
 262   struct DataDescriptor_64 {
 263     uint64_t _used : 58;
 264     uint32_t _kvo : 1;
 265     uint64_t _size;
 266     uint64_t _buffer;
 267     uint64_t GetSize() { return _size; }
 268   };
 269
 270
 271
 272   using NSDictionaryMSyntheticFrontEnd =
 273     GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 274 }
 275
 276 namespace Foundation1437 {
 277   static const uint64_t NSDictionaryCapacities[] = {
 278       0, 3, 7, 13, 23, 41, 71, 127, 191, 251, 383, 631, 1087, 1723,
 279       2803, 4523, 7351, 11959, 19447, 31231, 50683, 81919, 132607,
 280       214519, 346607, 561109, 907759, 1468927, 2376191, 3845119,
 281       6221311, 10066421, 16287743, 26354171, 42641881, 68996069,
 282       111638519, 180634607, 292272623, 472907251
 283   };
 284
 285   static const size_t NSDictionaryNumSizeBuckets = sizeof(NSDictionaryCapacities) / sizeof(uint64_t);
 286
 287   struct DataDescriptor_32 {
 288     uint32_t _buffer;
 289     union {
 290       struct {
 291         uint32_t _mutations;
 292       };
 293       struct {
 294         uint32_t _muts;
 295         uint32_t _used:25;
 296         uint32_t _kvo:1;
 297         uint32_t _szidx:6;
 298       };
 299     };
 300
 301     uint64_t GetSize() {
 302       return (_szidx) >= NSDictionaryNumSizeBuckets ?
 303           0 : NSDictionaryCapacities[_szidx];
 304     }
 305   };
 306
 307   struct DataDescriptor_64 {
 308     uint64_t _buffer;
 309     union {
 310       struct {
 311         uint64_t _mutations;
 312       };
 313       struct {
 314         uint32_t _muts;
 315         uint32_t _used:25;
 316         uint32_t _kvo:1;
 317         uint32_t _szidx:6;
 318       };
 319     };
 320
 321     uint64_t GetSize() {
 322       return (_szidx) >= NSDictionaryNumSizeBuckets ?
 323           0 : NSDictionaryCapacities[_szidx];
 324     }
 325   };
 326
 327   using NSDictionaryMSyntheticFrontEnd =
 328     GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 329
 330   template <typename DD>
 331   uint64_t
 332   __NSDictionaryMSize_Impl(lldb_private::Process &process,
 333                            lldb::addr_t valobj_addr, Status &error) {
 334     const lldb::addr_t start_of_descriptor =
 335         valobj_addr + process.GetAddressByteSize();
 336     DD descriptor = DD();
 337     process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),
 338                        error);
 339     if (error.Fail()) {
 340       return 0;
 341     }
 342     return descriptor._used;
 343   }
 344
 345   uint64_t
 346   __NSDictionaryMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
 347                Status &error) {
 348     if (process.GetAddressByteSize() == 4) {
 349       return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr,
 350                                                          error);
 351     } else {
 352       return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,
 353                                                          error);
 354     }
 355   }
 356
 357 }
 358 } // namespace formatters
 359 } // namespace lldb_private
 360
 361 template <bool name_entries>
 362 bool lldb_private::formatters::NSDictionarySummaryProvider(
 363     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 364   static ConstString g_TypeHint("NSDictionary");
 365   ProcessSP process_sp = valobj.GetProcessSP();
 366   if (!process_sp)
 367     return false;
 368
 369   ObjCLanguageRuntime *runtime =
 370       (ObjCLanguageRuntime *)process_sp->GetLanguageRuntime(
 371           lldb::eLanguageTypeObjC);
 372
 373   if (!runtime)
 374     return false;
 375
 376   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 377       runtime->GetClassDescriptor(valobj));
 378
 379   if (!descriptor || !descriptor->IsValid())
 380     return false;
 381
 382   uint32_t ptr_size = process_sp->GetAddressByteSize();
 383   bool is_64bit = (ptr_size == 8);
 384
 385   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
 386
 387   if (!valobj_addr)
 388     return false;
 389
 390   uint64_t value = 0;
 391
 392   ConstString class_name(descriptor->GetClassName());
 393
 394   static const ConstString g_DictionaryI("__NSDictionaryI");
 395   static const ConstString g_DictionaryM("__NSDictionaryM");
 396   static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");
 397   static const ConstString g_DictionaryMImmutable("__NSDictionaryM_Immutable");
 398   static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");
 399
 400   if (class_name.IsEmpty())
 401     return false;
 402
 403   if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {
 404     Status error;
 405     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 406                                                       ptr_size, 0, error);
 407     if (error.Fail())
 408       return false;
 409     value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
 410   } else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy) {
 411     AppleObjCRuntime *apple_runtime =
 412     llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
 413     Status error;
 414     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
 415       value = Foundation1437::__NSDictionaryMSize(*process_sp, valobj_addr,
 416                                                   error);
 417     } else {
 418       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
 419                                                         ptr_size, 0, error);
 420       value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
 421     }
 422     if (error.Fail())
 423       return false;
 424   } else if (class_name == g_Dictionary1) {
 425     value = 1;
 426   }
 427   /*else if (!strcmp(class_name,"__NSCFDictionary"))
 428    {
 429    Status error;
 430    value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ?
 431    20 : 12), 4, 0, error);
 432    if (error.Fail())
 433    return false;
 434    if (is_64bit)
 435    value &= ~0x0f1f000000000000UL;
 436    }*/
 437   else {
 438     auto &map(NSDictionary_Additionals::GetAdditionalSummaries());
 439     for (auto &candidate : map) {
 440       if (candidate.first && candidate.first->Match(class_name))
 441         return candidate.second(valobj, stream, options);
 442     }
 443     return false;
 444   }
 445
 446   std::string prefix, suffix;
 447   if (Language *language = Language::FindPlugin(options.GetLanguage())) {
 448     if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
 449                                             suffix)) {
 450       prefix.clear();
 451       suffix.clear();
 452     }
 453   }
 454
 455   stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "key/value pair",
 456                 value == 1 ? "" : "s", suffix.c_str());
 457   return true;
 458 }
 459
 460 SyntheticChildrenFrontEnd *
 461 lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
 462     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
 463   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 464   if (!process_sp)
 465     return nullptr;
 466   AppleObjCRuntime *runtime =
 467       llvm::dyn_cast_or_null<AppleObjCRuntime>(process_sp->GetObjCLanguageRuntime());
 468   if (!runtime)
 469     return nullptr;
 470
 471   CompilerType valobj_type(valobj_sp->GetCompilerType());
 472   Flags flags(valobj_type.GetTypeInfo());
 473
 474   if (flags.IsClear(eTypeIsPointer)) {
 475     Status error;
 476     valobj_sp = valobj_sp->AddressOf(error);
 477     if (error.Fail() || !valobj_sp)
 478       return nullptr;
 479   }
 480
 481   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
 482       runtime->GetClassDescriptor(*valobj_sp));
 483
 484   if (!descriptor || !descriptor->IsValid())
 485     return nullptr;
 486
 487   ConstString class_name(descriptor->GetClassName());
 488
 489   static const ConstString g_DictionaryI("__NSDictionaryI");
 490   static const ConstString g_DictionaryM("__NSDictionaryM");
 491   static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");
 492   static const ConstString g_DictionaryImmutable("__NSDictionaryM_Immutable");
 493   static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");
 494
 495   if (class_name.IsEmpty())
 496     return nullptr;
 497
 498   if (class_name == g_DictionaryI) {
 499     return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
 500   } else if (class_name == g_DictionaryM) {
 501     if (runtime->GetFoundationVersion() >= 1437) {
 502       return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp));
 503     } else if (runtime->GetFoundationVersion() >= 1428) {
 504       return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp));
 505     } else {
 506       return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
 507     }
 508   } else if (class_name == g_DictionaryMLegacy) {
 509       return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
 510   } else if (class_name == g_Dictionary1) {
 511     return (new NSDictionary1SyntheticFrontEnd(valobj_sp));
 512   } else {
 513     auto &map(NSDictionary_Additionals::GetAdditionalSynthetics());
 514     for (auto &candidate : map) {
 515       if (candidate.first && candidate.first->Match((class_name)))
 516         return candidate.second(synth, valobj_sp);
 517     }
 518   }
 519
 520   return nullptr;
 521 }
 522
 523 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
 524     NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 525     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 526       m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
 527       m_pair_type() {}
 528
 529 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
 530     ~NSDictionaryISyntheticFrontEnd() {
 531   delete m_data_32;
 532   m_data_32 = nullptr;
 533   delete m_data_64;
 534   m_data_64 = nullptr;
 535 }
 536
 537 size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
 538     GetIndexOfChildWithName(const ConstString &name) {
 539   const char *item_name = name.GetCString();
 540   uint32_t idx = ExtractIndexFromString(item_name);
 541   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 542     return UINT32_MAX;
 543   return idx;
 544 }
 545
 546 size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
 547     CalculateNumChildren() {
 548   if (!m_data_32 && !m_data_64)
 549     return 0;
 550   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 551 }
 552
 553 bool lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() {
 554   m_children.clear();
 555   delete m_data_32;
 556   m_data_32 = nullptr;
 557   delete m_data_64;
 558   m_data_64 = nullptr;
 559   m_ptr_size = 0;
 560   ValueObjectSP valobj_sp = m_backend.GetSP();
 561   if (!valobj_sp)
 562     return false;
 563   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 564   Status error;
 565   error.Clear();
 566   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 567   if (!process_sp)
 568     return false;
 569   m_ptr_size = process_sp->GetAddressByteSize();
 570   m_order = process_sp->GetByteOrder();
 571   uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
 572   if (m_ptr_size == 4) {
 573     m_data_32 = new DataDescriptor_32();
 574     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
 575                            error);
 576   } else {
 577     m_data_64 = new DataDescriptor_64();
 578     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
 579                            error);
 580   }
 581   if (error.Fail())
 582     return false;
 583   m_data_ptr = data_location + m_ptr_size;
 584   return false;
 585 }
 586
 587 bool lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
 588     MightHaveChildren() {
 589   return true;
 590 }
 591
 592 lldb::ValueObjectSP
 593 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex(
 594     size_t idx) {
 595   uint32_t num_children = CalculateNumChildren();
 596
 597   if (idx >= num_children)
 598     return lldb::ValueObjectSP();
 599
 600   if (m_children.empty()) {
 601     // do the scan phase
 602     lldb::addr_t key_at_idx = 0, val_at_idx = 0;
 603
 604     uint32_t tries = 0;
 605     uint32_t test_idx = 0;
 606
 607     while (tries < num_children) {
 608       key_at_idx = m_data_ptr + (2 * test_idx * m_ptr_size);
 609       val_at_idx = key_at_idx + m_ptr_size;
 610       ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
 611       if (!process_sp)
 612         return lldb::ValueObjectSP();
 613       Status error;
 614       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
 615       if (error.Fail())
 616         return lldb::ValueObjectSP();
 617       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
 618       if (error.Fail())
 619         return lldb::ValueObjectSP();
 620
 621       test_idx++;
 622
 623       if (!key_at_idx || !val_at_idx)
 624         continue;
 625       tries++;
 626
 627       DictionaryItemDescriptor descriptor = {key_at_idx, val_at_idx,
 628                                              lldb::ValueObjectSP()};
 629
 630       m_children.push_back(descriptor);
 631     }
 632   }
 633
 634   if (idx >= m_children.size()) // should never happen
 635     return lldb::ValueObjectSP();
 636
 637   DictionaryItemDescriptor &dict_item = m_children[idx];
 638   if (!dict_item.valobj_sp) {
 639     if (!m_pair_type.IsValid()) {
 640       TargetSP target_sp(m_backend.GetTargetSP());
 641       if (!target_sp)
 642         return ValueObjectSP();
 643       m_pair_type = GetLLDBNSPairType(target_sp);
 644     }
 645     if (!m_pair_type.IsValid())
 646       return ValueObjectSP();
 647
 648     DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 649
 650     if (m_ptr_size == 8) {
 651       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
 652       *data_ptr = dict_item.key_ptr;
 653       *(data_ptr + 1) = dict_item.val_ptr;
 654     } else {
 655       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
 656       *data_ptr = dict_item.key_ptr;
 657       *(data_ptr + 1) = dict_item.val_ptr;
 658     }
 659
 660     StreamString idx_name;
 661     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 662     DataExtractor data(buffer_sp, m_order, m_ptr_size);
 663     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
 664                                                     m_exe_ctx_ref, m_pair_type);
 665   }
 666   return dict_item.valobj_sp;
 667 }
 668
 669 lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
 670     NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 671     : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
 672
 673 size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
 674     GetIndexOfChildWithName(const ConstString &name) {
 675   static const ConstString g_zero("[0]");
 676
 677   if (name == g_zero)
 678     return 0;
 679
 680   return UINT32_MAX;
 681 }
 682
 683 size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
 684     CalculateNumChildren() {
 685   return 1;
 686 }
 687
 688 bool lldb_private::formatters::NSDictionary1SyntheticFrontEnd::Update() {
 689   m_pair.reset();
 690   return false;
 691 }
 692
 693 bool lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
 694     MightHaveChildren() {
 695   return true;
 696 }
 697
 698 lldb::ValueObjectSP
 699 lldb_private::formatters::NSDictionary1SyntheticFrontEnd::GetChildAtIndex(
 700     size_t idx) {
 701   if (idx != 0)
 702     return lldb::ValueObjectSP();
 703
 704   if (m_pair.get())
 705     return m_pair;
 706
 707   auto process_sp(m_backend.GetProcessSP());
 708   if (!process_sp)
 709     return nullptr;
 710
 711   auto ptr_size = process_sp->GetAddressByteSize();
 712
 713   lldb::addr_t key_ptr =
 714       m_backend.GetValueAsUnsigned(LLDB_INVALID_ADDRESS) + ptr_size;
 715   lldb::addr_t value_ptr = key_ptr + ptr_size;
 716
 717   Status error;
 718
 719   lldb::addr_t value_at_idx = process_sp->ReadPointerFromMemory(key_ptr, error);
 720   if (error.Fail())
 721     return nullptr;
 722   lldb::addr_t key_at_idx = process_sp->ReadPointerFromMemory(value_ptr, error);
 723   if (error.Fail())
 724     return nullptr;
 725
 726   auto pair_type =
 727       GetLLDBNSPairType(process_sp->GetTarget().shared_from_this());
 728
 729   DataBufferSP buffer_sp(new DataBufferHeap(2 * ptr_size, 0));
 730
 731   if (ptr_size == 8) {
 732     uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
 733     *data_ptr = key_at_idx;
 734     *(data_ptr + 1) = value_at_idx;
 735   } else {
 736     uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
 737     *data_ptr = key_at_idx;
 738     *(data_ptr + 1) = value_at_idx;
 739   }
 740
 741   DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size);
 742   m_pair = CreateValueObjectFromData(
 743       "[0]", data, m_backend.GetExecutionContextRef(), pair_type);
 744
 745   return m_pair;
 746 }
 747
 748 template <typename D32, typename D64>
 749 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
 750     GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 751     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 752       m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
 753       m_pair_type() {}
 754
 755 template <typename D32, typename D64>
 756 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
 757     ~GenericNSDictionaryMSyntheticFrontEnd() {
 758   delete m_data_32;
 759   m_data_32 = nullptr;
 760   delete m_data_64;
 761   m_data_64 = nullptr;
 762 }
 763
 764 template <typename D32, typename D64>
 765 size_t
 766 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::    GetIndexOfChildWithName(const ConstString &name) {
 767   const char *item_name = name.GetCString();
 768   uint32_t idx = ExtractIndexFromString(item_name);
 769   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 770     return UINT32_MAX;
 771   return idx;
 772 }
 773
 774 template <typename D32, typename D64>
 775 size_t
 776 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::CalculateNumChildren() {
 777   if (!m_data_32 && !m_data_64)
 778     return 0;
 779   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 780 }
 781
 782 template <typename D32, typename D64>
 783 bool
 784 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
 785   Update() {
 786   m_children.clear();
 787   ValueObjectSP valobj_sp = m_backend.GetSP();
 788   m_ptr_size = 0;
 789   delete m_data_32;
 790   m_data_32 = nullptr;
 791   delete m_data_64;
 792   m_data_64 = nullptr;
 793   if (!valobj_sp)
 794     return false;
 795   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 796   Status error;
 797   error.Clear();
 798   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 799   if (!process_sp)
 800     return false;
 801   m_ptr_size = process_sp->GetAddressByteSize();
 802   m_order = process_sp->GetByteOrder();
 803   uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
 804   if (m_ptr_size == 4) {
 805     m_data_32 = new D32();
 806     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
 807                            error);
 808   } else {
 809     m_data_64 = new D64();
 810     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
 811                            error);
 812   }
 813   if (error.Fail())
 814     return false;
 815   return false;
 816 }
 817
 818 template <typename D32, typename D64>
 819 bool
 820 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
 821     MightHaveChildren() {
 822   return true;
 823 }
 824
 825 template <typename D32, typename D64>
 826 lldb::ValueObjectSP
 827 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
 828     GetChildAtIndex(
 829     size_t idx) {
 830   lldb::addr_t m_keys_ptr;
 831   lldb::addr_t m_values_ptr;
 832   if (m_data_32) {
 833     uint32_t size = m_data_32->GetSize();
 834     m_keys_ptr = m_data_32->_buffer;
 835     m_values_ptr = m_data_32->_buffer + (m_ptr_size * size);
 836   } else {
 837     uint32_t size = m_data_64->GetSize();
 838     m_keys_ptr = m_data_64->_buffer;
 839     m_values_ptr = m_data_64->_buffer + (m_ptr_size * size);
 840   }
 841
 842   uint32_t num_children = CalculateNumChildren();
 843
 844   if (idx >= num_children)
 845     return lldb::ValueObjectSP();
 846
 847   if (m_children.empty()) {
 848     // do the scan phase
 849     lldb::addr_t key_at_idx = 0, val_at_idx = 0;
 850
 851     uint32_t tries = 0;
 852     uint32_t test_idx = 0;
 853
 854     while (tries < num_children) {
 855       key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
 856       val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
 857       ;
 858       ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
 859       if (!process_sp)
 860         return lldb::ValueObjectSP();
 861       Status error;
 862       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
 863       if (error.Fail())
 864         return lldb::ValueObjectSP();
 865       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
 866       if (error.Fail())
 867         return lldb::ValueObjectSP();
 868
 869       test_idx++;
 870
 871       if (!key_at_idx || !val_at_idx)
 872         continue;
 873       tries++;
 874
 875       DictionaryItemDescriptor descriptor = {key_at_idx, val_at_idx,
 876                                              lldb::ValueObjectSP()};
 877
 878       m_children.push_back(descriptor);
 879     }
 880   }
 881
 882   if (idx >= m_children.size()) // should never happen
 883     return lldb::ValueObjectSP();
 884
 885   DictionaryItemDescriptor &dict_item = m_children[idx];
 886   if (!dict_item.valobj_sp) {
 887     if (!m_pair_type.IsValid()) {
 888       TargetSP target_sp(m_backend.GetTargetSP());
 889       if (!target_sp)
 890         return ValueObjectSP();
 891       m_pair_type = GetLLDBNSPairType(target_sp);
 892     }
 893     if (!m_pair_type.IsValid())
 894       return ValueObjectSP();
 895
 896     DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
 897
 898     if (m_ptr_size == 8) {
 899       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
 900       *data_ptr = dict_item.key_ptr;
 901       *(data_ptr + 1) = dict_item.val_ptr;
 902     } else {
 903       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
 904       *data_ptr = dict_item.key_ptr;
 905       *(data_ptr + 1) = dict_item.val_ptr;
 906     }
 907
 908     StreamString idx_name;
 909     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 910     DataExtractor data(buffer_sp, m_order, m_ptr_size);
 911     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
 912                                                     m_exe_ctx_ref, m_pair_type);
 913   }
 914   return dict_item.valobj_sp;
 915 }
 916
 917
 918 lldb_private::formatters::Foundation1100::
 919   NSDictionaryMSyntheticFrontEnd::
 920     NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 921     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
 922       m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
 923       m_pair_type() {}
 924
 925 lldb_private::formatters::Foundation1100::
 926   NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd() {
 927   delete m_data_32;
 928   m_data_32 = nullptr;
 929   delete m_data_64;
 930   m_data_64 = nullptr;
 931 }
 932
 933 size_t
 934 lldb_private::formatters::Foundation1100::
 935   NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) {
 936   const char *item_name = name.GetCString();
 937   uint32_t idx = ExtractIndexFromString(item_name);
 938   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 939     return UINT32_MAX;
 940   return idx;
 941 }
 942
 943 size_t
 944 lldb_private::formatters::Foundation1100::
 945   NSDictionaryMSyntheticFrontEnd::CalculateNumChildren() {
 946   if (!m_data_32 && !m_data_64)
 947     return 0;
 948   return (m_data_32 ? m_data_32->_used : m_data_64->_used);
 949 }
 950
 951 bool
 952 lldb_private::formatters::Foundation1100::
 953   NSDictionaryMSyntheticFrontEnd::Update() {
 954   m_children.clear();
 955   ValueObjectSP valobj_sp = m_backend.GetSP();
 956   m_ptr_size = 0;
 957   delete m_data_32;
 958   m_data_32 = nullptr;
 959   delete m_data_64;
 960   m_data_64 = nullptr;
 961   if (!valobj_sp)
 962     return false;
 963   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 964   Status error;
 965   error.Clear();
 966   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
 967   if (!process_sp)
 968     return false;
 969   m_ptr_size = process_sp->GetAddressByteSize();
 970   m_order = process_sp->GetByteOrder();
 971   uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
 972   if (m_ptr_size == 4) {
 973     m_data_32 = new DataDescriptor_32();
 974     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
 975                            error);
 976   } else {
 977     m_data_64 = new DataDescriptor_64();
 978     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
 979                            error);
 980   }
 981   if (error.Fail())
 982     return false;
 983   return false;
 984 }
 985
 986 bool
 987 lldb_private::formatters::Foundation1100::
 988   NSDictionaryMSyntheticFrontEnd::MightHaveChildren() {
 989   return true;
 990 }
 991
 992 lldb::ValueObjectSP
 993 lldb_private::formatters::Foundation1100::
 994   NSDictionaryMSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
 995   lldb::addr_t m_keys_ptr =
 996       (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr);
 997   lldb::addr_t m_values_ptr =
 998       (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
 999
1000   uint32_t num_children = CalculateNumChildren();
1001
1002   if (idx >= num_children)
1003     return lldb::ValueObjectSP();
1004
1005   if (m_children.empty()) {
1006     // do the scan phase
1007     lldb::addr_t key_at_idx = 0, val_at_idx = 0;
1008
1009     uint32_t tries = 0;
1010     uint32_t test_idx = 0;
1011
1012     while (tries < num_children) {
1013       key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
1014       val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
1015       ;
1016       ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
1017       if (!process_sp)
1018         return lldb::ValueObjectSP();
1019       Status error;
1020       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
1021       if (error.Fail())
1022         return lldb::ValueObjectSP();
1023       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
1024       if (error.Fail())
1025         return lldb::ValueObjectSP();
1026
1027       test_idx++;
1028
1029       if (!key_at_idx || !val_at_idx)
1030         continue;
1031       tries++;
1032
1033       DictionaryItemDescriptor descriptor = {key_at_idx, val_at_idx,
1034                                              lldb::ValueObjectSP()};
1035
1036       m_children.push_back(descriptor);
1037     }
1038   }
1039
1040   if (idx >= m_children.size()) // should never happen
1041     return lldb::ValueObjectSP();
1042
1043   DictionaryItemDescriptor &dict_item = m_children[idx];
1044   if (!dict_item.valobj_sp) {
1045     if (!m_pair_type.IsValid()) {
1046       TargetSP target_sp(m_backend.GetTargetSP());
1047       if (!target_sp)
1048         return ValueObjectSP();
1049       m_pair_type = GetLLDBNSPairType(target_sp);
1050     }
1051     if (!m_pair_type.IsValid())
1052       return ValueObjectSP();
1053
1054     DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
1055
1056     if (m_ptr_size == 8) {
1057       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1058       *data_ptr = dict_item.key_ptr;
1059       *(data_ptr + 1) = dict_item.val_ptr;
1060     } else {
1061       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
1062       *data_ptr = dict_item.key_ptr;
1063       *(data_ptr + 1) = dict_item.val_ptr;
1064     }
1065
1066     StreamString idx_name;
1067     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
1068     DataExtractor data(buffer_sp, m_order, m_ptr_size);
1069     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
1070                                                     m_exe_ctx_ref, m_pair_type);
1071   }
1072   return dict_item.valobj_sp;
1073 }
1074
1075 template bool lldb_private::formatters::NSDictionarySummaryProvider<true>(
1076     ValueObject &, Stream &, const TypeSummaryOptions &);
1077
1078 template bool lldb_private::formatters::NSDictionarySummaryProvider<false>(
1079     ValueObject &, Stream &, const TypeSummaryOptions &);