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 constexpr llvm::StringLiteral 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 llvm::StringRef prefix, suffix; 449 if (Language *language = Language::FindPlugin(options.GetLanguage())) 450 std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint); 451 452 stream << prefix; 453 stream.Printf("%" PRIu64 " %s%s", value, "element", value == 1 ? "" : "s"); 454 stream << suffix; 455 return true; 456 } 457 458 lldb_private::formatters::NSArrayMSyntheticFrontEndBase:: 459 NSArrayMSyntheticFrontEndBase(lldb::ValueObjectSP valobj_sp) 460 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_id_type() { 461 if (valobj_sp) { 462 TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget( 463 *valobj_sp->GetExecutionContextRef().GetTargetSP()); 464 if (scratch_ts_sp) 465 m_id_type = CompilerType( 466 scratch_ts_sp->weak_from_this(), 467 scratch_ts_sp->getASTContext().ObjCBuiltinIdTy.getAsOpaquePtr()); 468 if (valobj_sp->GetProcessSP()) 469 m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize(); 470 } 471 } 472 473 template <typename D32, typename D64> 474 lldb_private::formatters:: 475 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 476 GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 477 : NSArrayMSyntheticFrontEndBase(valobj_sp), m_data_32(nullptr), 478 m_data_64(nullptr) {} 479 480 size_t 481 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::CalculateNumChildren() { 482 return GetUsedCount(); 483 } 484 485 lldb::ValueObjectSP 486 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetChildAtIndex( 487 size_t idx) { 488 if (idx >= CalculateNumChildren()) 489 return lldb::ValueObjectSP(); 490 lldb::addr_t object_at_idx = GetDataAddress(); 491 size_t pyhs_idx = idx; 492 pyhs_idx += GetOffset(); 493 if (GetSize() <= pyhs_idx) 494 pyhs_idx -= GetSize(); 495 object_at_idx += (pyhs_idx * m_ptr_size); 496 StreamString idx_name; 497 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); 498 return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx, 499 m_exe_ctx_ref, m_id_type); 500 } 501 502 template <typename D32, typename D64> 503 bool 504 lldb_private::formatters:: 505 GenericNSArrayMSyntheticFrontEnd<D32, D64>::Update() { 506 ValueObjectSP valobj_sp = m_backend.GetSP(); 507 m_ptr_size = 0; 508 delete m_data_32; 509 m_data_32 = nullptr; 510 delete m_data_64; 511 m_data_64 = nullptr; 512 if (!valobj_sp) 513 return false; 514 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); 515 Status error; 516 error.Clear(); 517 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 518 if (!process_sp) 519 return false; 520 m_ptr_size = process_sp->GetAddressByteSize(); 521 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; 522 if (m_ptr_size == 4) { 523 m_data_32 = new D32(); 524 process_sp->ReadMemory(data_location, m_data_32, sizeof(D32), 525 error); 526 } else { 527 m_data_64 = new D64(); 528 process_sp->ReadMemory(data_location, m_data_64, sizeof(D64), 529 error); 530 } 531 532 return error.Success(); 533 } 534 535 bool 536 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::MightHaveChildren() { 537 return true; 538 } 539 540 size_t 541 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName( 542 ConstString name) { 543 const char *item_name = name.GetCString(); 544 uint32_t idx = ExtractIndexFromString(item_name); 545 if (idx < UINT32_MAX && idx >= CalculateNumChildren()) 546 return UINT32_MAX; 547 return idx; 548 } 549 550 template <typename D32, typename D64> 551 lldb_private::formatters:: 552 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 553 ~GenericNSArrayMSyntheticFrontEnd<D32, D64>() { 554 delete m_data_32; 555 m_data_32 = nullptr; 556 delete m_data_64; 557 m_data_64 = nullptr; 558 } 559 560 template <typename D32, typename D64> 561 lldb::addr_t 562 lldb_private::formatters:: 563 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 564 GenericNSArrayMSyntheticFrontEnd::GetDataAddress() { 565 if (!m_data_32 && !m_data_64) 566 return LLDB_INVALID_ADDRESS; 567 return m_data_32 ? m_data_32->_data : m_data_64->_data; 568 } 569 570 template <typename D32, typename D64> 571 uint64_t 572 lldb_private::formatters:: 573 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 574 GenericNSArrayMSyntheticFrontEnd::GetUsedCount() { 575 if (!m_data_32 && !m_data_64) 576 return 0; 577 return m_data_32 ? m_data_32->_used : m_data_64->_used; 578 } 579 580 template <typename D32, typename D64> 581 uint64_t 582 lldb_private::formatters:: 583 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 584 GenericNSArrayMSyntheticFrontEnd::GetOffset() { 585 if (!m_data_32 && !m_data_64) 586 return 0; 587 return m_data_32 ? m_data_32->_offset : m_data_64->_offset; 588 } 589 590 template <typename D32, typename D64> 591 uint64_t 592 lldb_private::formatters:: 593 GenericNSArrayMSyntheticFrontEnd<D32, D64>:: 594 GenericNSArrayMSyntheticFrontEnd::GetSize() { 595 if (!m_data_32 && !m_data_64) 596 return 0; 597 return m_data_32 ? m_data_32->_size : m_data_64->_size; 598 } 599 600 template <typename D32, typename D64, bool Inline> 601 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 602 GenericNSArrayISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 603 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), 604 m_data_32(nullptr), m_data_64(nullptr) { 605 if (valobj_sp) { 606 CompilerType type = valobj_sp->GetCompilerType(); 607 if (type) { 608 TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget( 609 *valobj_sp->GetExecutionContextRef().GetTargetSP()); 610 if (scratch_ts_sp) 611 m_id_type = scratch_ts_sp->GetType( 612 scratch_ts_sp->getASTContext().ObjCBuiltinIdTy); 613 } 614 } 615 } 616 617 template <typename D32, typename D64, bool Inline> 618 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 619 ~GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>() { 620 delete m_data_32; 621 m_data_32 = nullptr; 622 delete m_data_64; 623 m_data_64 = nullptr; 624 } 625 626 template <typename D32, typename D64, bool Inline> 627 size_t 628 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 629 GetIndexOfChildWithName(ConstString name) { 630 const char *item_name = name.GetCString(); 631 uint32_t idx = ExtractIndexFromString(item_name); 632 if (idx < UINT32_MAX && idx >= CalculateNumChildren()) 633 return UINT32_MAX; 634 return idx; 635 } 636 637 template <typename D32, typename D64, bool Inline> 638 size_t 639 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 640 CalculateNumChildren() { 641 return m_data_32 ? m_data_32->used : m_data_64->used; 642 } 643 644 template <typename D32, typename D64, bool Inline> 645 bool 646 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 647 Update() { 648 ValueObjectSP valobj_sp = m_backend.GetSP(); 649 m_ptr_size = 0; 650 delete m_data_32; 651 m_data_32 = nullptr; 652 delete m_data_64; 653 m_data_64 = nullptr; 654 if (!valobj_sp) 655 return false; 656 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); 657 Status error; 658 error.Clear(); 659 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 660 if (!process_sp) 661 return false; 662 m_ptr_size = process_sp->GetAddressByteSize(); 663 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; 664 if (m_ptr_size == 4) { 665 m_data_32 = new D32(); 666 process_sp->ReadMemory(data_location, m_data_32, sizeof(D32), 667 error); 668 } else { 669 m_data_64 = new D64(); 670 process_sp->ReadMemory(data_location, m_data_64, sizeof(D64), 671 error); 672 } 673 674 return error.Success(); 675 } 676 677 template <typename D32, typename D64, bool Inline> 678 bool 679 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 680 MightHaveChildren() { 681 return true; 682 } 683 684 template <typename D32, typename D64, bool Inline> 685 lldb::ValueObjectSP 686 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: 687 GetChildAtIndex(size_t idx) { 688 if (idx >= CalculateNumChildren()) 689 return lldb::ValueObjectSP(); 690 lldb::addr_t object_at_idx; 691 if (Inline) { 692 object_at_idx = m_backend.GetSP()->GetValueAsUnsigned(0) + m_ptr_size; 693 object_at_idx += m_ptr_size == 4 ? sizeof(D32) : sizeof(D64); // skip the data header 694 object_at_idx -= m_ptr_size; // we treat the last entry in the data header as the first pointer 695 } else { 696 object_at_idx = m_data_32 ? m_data_32->list : m_data_64->list; 697 } 698 object_at_idx += (idx * m_ptr_size); 699 700 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); 701 if (!process_sp) 702 return lldb::ValueObjectSP(); 703 Status error; 704 if (error.Fail()) 705 return lldb::ValueObjectSP(); 706 StreamString idx_name; 707 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); 708 return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx, 709 m_exe_ctx_ref, m_id_type); 710 } 711 712 lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd( 713 lldb::ValueObjectSP valobj_sp) 714 : SyntheticChildrenFrontEnd(*valobj_sp) {} 715 716 size_t 717 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName( 718 ConstString name) { 719 return UINT32_MAX; 720 } 721 722 size_t 723 lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren() { 724 return 0; 725 } 726 727 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::Update() { 728 return false; 729 } 730 731 bool lldb_private::formatters::NSArray0SyntheticFrontEnd::MightHaveChildren() { 732 return false; 733 } 734 735 lldb::ValueObjectSP 736 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetChildAtIndex( 737 size_t idx) { 738 return lldb::ValueObjectSP(); 739 } 740 741 lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd( 742 lldb::ValueObjectSP valobj_sp) 743 : SyntheticChildrenFrontEnd(*valobj_sp.get()) {} 744 745 size_t 746 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName( 747 ConstString name) { 748 static const ConstString g_zero("[0]"); 749 750 if (name == g_zero) 751 return 0; 752 753 return UINT32_MAX; 754 } 755 756 size_t 757 lldb_private::formatters::NSArray1SyntheticFrontEnd::CalculateNumChildren() { 758 return 1; 759 } 760 761 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::Update() { 762 return false; 763 } 764 765 bool lldb_private::formatters::NSArray1SyntheticFrontEnd::MightHaveChildren() { 766 return true; 767 } 768 769 lldb::ValueObjectSP 770 lldb_private::formatters::NSArray1SyntheticFrontEnd::GetChildAtIndex( 771 size_t idx) { 772 static const ConstString g_zero("[0]"); 773 774 if (idx == 0) { 775 TypeSystemClangSP scratch_ts_sp = 776 ScratchTypeSystemClang::GetForTarget(*m_backend.GetTargetSP()); 777 if (scratch_ts_sp) { 778 CompilerType id_type(scratch_ts_sp->GetBasicType(lldb::eBasicTypeObjCID)); 779 return m_backend.GetSyntheticChildAtOffset( 780 m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true, 781 g_zero); 782 } 783 } 784 return lldb::ValueObjectSP(); 785 } 786 787 SyntheticChildrenFrontEnd * 788 lldb_private::formatters::NSArraySyntheticFrontEndCreator( 789 CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) { 790 if (!valobj_sp) 791 return nullptr; 792 793 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 794 if (!process_sp) 795 return nullptr; 796 AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>( 797 ObjCLanguageRuntime::Get(*process_sp)); 798 if (!runtime) 799 return nullptr; 800 801 CompilerType valobj_type(valobj_sp->GetCompilerType()); 802 Flags flags(valobj_type.GetTypeInfo()); 803 804 if (flags.IsClear(eTypeIsPointer)) { 805 Status error; 806 valobj_sp = valobj_sp->AddressOf(error); 807 if (error.Fail() || !valobj_sp) 808 return nullptr; 809 } 810 811 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 812 runtime->GetClassDescriptor(*valobj_sp)); 813 814 if (!descriptor || !descriptor->IsValid()) 815 return nullptr; 816 817 ConstString class_name(descriptor->GetClassName()); 818 819 static const ConstString g_NSArrayI("__NSArrayI"); 820 static const ConstString g_NSConstantArray("NSConstantArray"); 821 static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer"); 822 static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM"); 823 static const ConstString g_NSArrayM("__NSArrayM"); 824 static const ConstString g_NSArray0("__NSArray0"); 825 static const ConstString g_NSArray1("__NSSingleObjectArrayI"); 826 static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy"); 827 static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable"); 828 static const ConstString g_NSCallStackArray("_NSCallStackArray"); 829 830 if (class_name.IsEmpty()) 831 return nullptr; 832 833 if (class_name == g_NSArrayI) { 834 if (runtime->GetFoundationVersion() >= 1436) 835 return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp)); 836 if (runtime->GetFoundationVersion() >= 1430) 837 return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp)); 838 return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp)); 839 } else if (class_name == g_NSArrayI_Transfer) { 840 return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp)); 841 } else if (class_name == g_NSConstantArray) { 842 return new ConstantArray::NSConstantArraySyntheticFrontEnd(valobj_sp); 843 } else if (class_name == g_NSFrozenArrayM) { 844 return (new Foundation1436::NSFrozenArrayMSyntheticFrontEnd(valobj_sp)); 845 } else if (class_name == g_NSArray0) { 846 return (new NSArray0SyntheticFrontEnd(valobj_sp)); 847 } else if (class_name == g_NSArray1) { 848 return (new NSArray1SyntheticFrontEnd(valobj_sp)); 849 } else if (class_name == g_NSArrayM) { 850 if (runtime->GetFoundationVersion() >= 1437) 851 return (new Foundation1437::NSArrayMSyntheticFrontEnd(valobj_sp)); 852 if (runtime->GetFoundationVersion() >= 1428) 853 return (new Foundation1428::NSArrayMSyntheticFrontEnd(valobj_sp)); 854 if (runtime->GetFoundationVersion() >= 1100) 855 return (new Foundation1010::NSArrayMSyntheticFrontEnd(valobj_sp)); 856 } else if (class_name == g_NSCallStackArray) { 857 return (new CallStackArray::NSCallStackArraySyntheticFrontEnd(valobj_sp)); 858 } else { 859 auto &map(NSArray_Additionals::GetAdditionalSynthetics()); 860 auto iter = map.find(class_name), end = map.end(); 861 if (iter != end) 862 return iter->second(synth, valobj_sp); 863 } 864 865 return nullptr; 866 } 867