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 } 871