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