1 //===-- Cocoa.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 "Cocoa.h" 10 11 #include "lldb/Core/Mangled.h" 12 #include "lldb/Core/ValueObject.h" 13 #include "lldb/Core/ValueObjectConstResult.h" 14 #include "lldb/DataFormatters/FormattersHelpers.h" 15 #include "lldb/DataFormatters/StringPrinter.h" 16 #include "lldb/DataFormatters/TypeSummary.h" 17 #include "lldb/Host/Time.h" 18 #include "lldb/Symbol/ClangASTContext.h" 19 #include "lldb/Target/Language.h" 20 #include "lldb/Target/Process.h" 21 #include "lldb/Target/ProcessStructReader.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 #include "llvm/ADT/APInt.h" 29 #include "llvm/ADT/bit.h" 30 31 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h" 32 33 #include "NSString.h" 34 35 using namespace lldb; 36 using namespace lldb_private; 37 using namespace lldb_private::formatters; 38 39 bool lldb_private::formatters::NSBundleSummaryProvider( 40 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 41 ProcessSP process_sp = valobj.GetProcessSP(); 42 if (!process_sp) 43 return false; 44 45 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 46 47 if (!runtime) 48 return false; 49 50 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 51 runtime->GetClassDescriptor(valobj)); 52 53 if (!descriptor || !descriptor->IsValid()) 54 return false; 55 56 uint32_t ptr_size = process_sp->GetAddressByteSize(); 57 58 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 59 60 if (!valobj_addr) 61 return false; 62 63 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 64 65 if (class_name.empty()) 66 return false; 67 68 if (class_name == "NSBundle") { 69 uint64_t offset = 5 * ptr_size; 70 ValueObjectSP text(valobj.GetSyntheticChildAtOffset( 71 offset, 72 valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID), 73 true)); 74 75 StreamString summary_stream; 76 bool was_nsstring_ok = 77 NSStringSummaryProvider(*text, summary_stream, options); 78 if (was_nsstring_ok && summary_stream.GetSize() > 0) { 79 stream.Printf("%s", summary_stream.GetData()); 80 return true; 81 } 82 } 83 84 return false; 85 } 86 87 bool lldb_private::formatters::NSTimeZoneSummaryProvider( 88 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 89 ProcessSP process_sp = valobj.GetProcessSP(); 90 if (!process_sp) 91 return false; 92 93 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 94 95 if (!runtime) 96 return false; 97 98 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 99 runtime->GetClassDescriptor(valobj)); 100 101 if (!descriptor || !descriptor->IsValid()) 102 return false; 103 104 uint32_t ptr_size = process_sp->GetAddressByteSize(); 105 106 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 107 108 if (!valobj_addr) 109 return false; 110 111 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 112 113 if (class_name.empty()) 114 return false; 115 116 if (class_name == "__NSTimeZone") { 117 uint64_t offset = ptr_size; 118 ValueObjectSP text(valobj.GetSyntheticChildAtOffset( 119 offset, valobj.GetCompilerType(), true)); 120 StreamString summary_stream; 121 bool was_nsstring_ok = 122 NSStringSummaryProvider(*text, summary_stream, options); 123 if (was_nsstring_ok && summary_stream.GetSize() > 0) { 124 stream.Printf("%s", summary_stream.GetData()); 125 return true; 126 } 127 } 128 129 return false; 130 } 131 132 bool lldb_private::formatters::NSNotificationSummaryProvider( 133 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 134 ProcessSP process_sp = valobj.GetProcessSP(); 135 if (!process_sp) 136 return false; 137 138 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 139 140 if (!runtime) 141 return false; 142 143 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 144 runtime->GetClassDescriptor(valobj)); 145 146 if (!descriptor || !descriptor->IsValid()) 147 return false; 148 149 uint32_t ptr_size = process_sp->GetAddressByteSize(); 150 151 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 152 153 if (!valobj_addr) 154 return false; 155 156 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 157 158 if (class_name.empty()) 159 return false; 160 161 if (class_name == "NSConcreteNotification") { 162 uint64_t offset = ptr_size; 163 ValueObjectSP text(valobj.GetSyntheticChildAtOffset( 164 offset, valobj.GetCompilerType(), true)); 165 StreamString summary_stream; 166 bool was_nsstring_ok = 167 NSStringSummaryProvider(*text, summary_stream, options); 168 if (was_nsstring_ok && summary_stream.GetSize() > 0) { 169 stream.Printf("%s", summary_stream.GetData()); 170 return true; 171 } 172 } 173 174 return false; 175 } 176 177 bool lldb_private::formatters::NSMachPortSummaryProvider( 178 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 179 ProcessSP process_sp = valobj.GetProcessSP(); 180 if (!process_sp) 181 return false; 182 183 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 184 185 if (!runtime) 186 return false; 187 188 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 189 runtime->GetClassDescriptor(valobj)); 190 191 if (!descriptor || !descriptor->IsValid()) 192 return false; 193 194 uint32_t ptr_size = process_sp->GetAddressByteSize(); 195 196 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 197 198 if (!valobj_addr) 199 return false; 200 201 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 202 203 if (class_name.empty()) 204 return false; 205 206 uint64_t port_number = 0; 207 208 if (class_name == "NSMachPort") { 209 uint64_t offset = (ptr_size == 4 ? 12 : 20); 210 Status error; 211 port_number = process_sp->ReadUnsignedIntegerFromMemory( 212 offset + valobj_addr, 4, 0, error); 213 if (error.Success()) { 214 stream.Printf("mach port: %u", 215 (uint32_t)(port_number & 0x00000000FFFFFFFF)); 216 return true; 217 } 218 } 219 220 return false; 221 } 222 223 bool lldb_private::formatters::NSIndexSetSummaryProvider( 224 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 225 ProcessSP process_sp = valobj.GetProcessSP(); 226 if (!process_sp) 227 return false; 228 229 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 230 231 if (!runtime) 232 return false; 233 234 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 235 runtime->GetClassDescriptor(valobj)); 236 237 if (!descriptor || !descriptor->IsValid()) 238 return false; 239 240 uint32_t ptr_size = process_sp->GetAddressByteSize(); 241 242 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 243 244 if (!valobj_addr) 245 return false; 246 247 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 248 249 if (class_name.empty()) 250 return false; 251 252 uint64_t count = 0; 253 254 do { 255 if (class_name == "NSIndexSet" || class_name == "NSMutableIndexSet") { 256 Status error; 257 uint32_t mode = process_sp->ReadUnsignedIntegerFromMemory( 258 valobj_addr + ptr_size, 4, 0, error); 259 if (error.Fail()) 260 return false; 261 // this means the set is empty - count = 0 262 if ((mode & 1) == 1) { 263 count = 0; 264 break; 265 } 266 if ((mode & 2) == 2) 267 mode = 1; // this means the set only has one range 268 else 269 mode = 2; // this means the set has multiple ranges 270 if (mode == 1) { 271 count = process_sp->ReadUnsignedIntegerFromMemory( 272 valobj_addr + 3 * ptr_size, ptr_size, 0, error); 273 if (error.Fail()) 274 return false; 275 } else { 276 // read a pointer to the data at 2*ptr_size 277 count = process_sp->ReadUnsignedIntegerFromMemory( 278 valobj_addr + 2 * ptr_size, ptr_size, 0, error); 279 if (error.Fail()) 280 return false; 281 // read the data at 2*ptr_size from the first location 282 count = process_sp->ReadUnsignedIntegerFromMemory(count + 2 * ptr_size, 283 ptr_size, 0, error); 284 if (error.Fail()) 285 return false; 286 } 287 } else 288 return false; 289 } while (false); 290 stream.Printf("%" PRIu64 " index%s", count, (count == 1 ? "" : "es")); 291 return true; 292 } 293 294 static void NSNumber_FormatChar(ValueObject &valobj, Stream &stream, char value, 295 lldb::LanguageType lang) { 296 static ConstString g_TypeHint("NSNumber:char"); 297 298 std::string prefix, suffix; 299 if (Language *language = Language::FindPlugin(lang)) { 300 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 301 suffix)) { 302 prefix.clear(); 303 suffix.clear(); 304 } 305 } 306 307 stream.Printf("%s%hhd%s", prefix.c_str(), value, suffix.c_str()); 308 } 309 310 static void NSNumber_FormatShort(ValueObject &valobj, Stream &stream, 311 short value, lldb::LanguageType lang) { 312 static ConstString g_TypeHint("NSNumber:short"); 313 314 std::string prefix, suffix; 315 if (Language *language = Language::FindPlugin(lang)) { 316 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 317 suffix)) { 318 prefix.clear(); 319 suffix.clear(); 320 } 321 } 322 323 stream.Printf("%s%hd%s", prefix.c_str(), value, suffix.c_str()); 324 } 325 326 static void NSNumber_FormatInt(ValueObject &valobj, Stream &stream, int value, 327 lldb::LanguageType lang) { 328 static ConstString g_TypeHint("NSNumber:int"); 329 330 std::string prefix, suffix; 331 if (Language *language = Language::FindPlugin(lang)) { 332 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 333 suffix)) { 334 prefix.clear(); 335 suffix.clear(); 336 } 337 } 338 339 stream.Printf("%s%d%s", prefix.c_str(), value, suffix.c_str()); 340 } 341 342 static void NSNumber_FormatLong(ValueObject &valobj, Stream &stream, 343 uint64_t value, lldb::LanguageType lang) { 344 static ConstString g_TypeHint("NSNumber:long"); 345 346 std::string prefix, suffix; 347 if (Language *language = Language::FindPlugin(lang)) { 348 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 349 suffix)) { 350 prefix.clear(); 351 suffix.clear(); 352 } 353 } 354 355 stream.Printf("%s%" PRId64 "%s", prefix.c_str(), value, suffix.c_str()); 356 } 357 358 static void NSNumber_FormatInt128(ValueObject &valobj, Stream &stream, 359 const llvm::APInt &value, 360 lldb::LanguageType lang) { 361 static ConstString g_TypeHint("NSNumber:int128_t"); 362 363 std::string prefix, suffix; 364 if (Language *language = Language::FindPlugin(lang)) { 365 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 366 suffix)) { 367 prefix.clear(); 368 suffix.clear(); 369 } 370 } 371 372 stream.PutCString(prefix.c_str()); 373 const int radix = 10; 374 const bool isSigned = true; 375 std::string str = value.toString(radix, isSigned); 376 stream.PutCString(str.c_str()); 377 stream.PutCString(suffix.c_str()); 378 } 379 380 static void NSNumber_FormatFloat(ValueObject &valobj, Stream &stream, 381 float value, lldb::LanguageType lang) { 382 static ConstString g_TypeHint("NSNumber:float"); 383 384 std::string prefix, suffix; 385 if (Language *language = Language::FindPlugin(lang)) { 386 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 387 suffix)) { 388 prefix.clear(); 389 suffix.clear(); 390 } 391 } 392 393 stream.Printf("%s%f%s", prefix.c_str(), value, suffix.c_str()); 394 } 395 396 static void NSNumber_FormatDouble(ValueObject &valobj, Stream &stream, 397 double value, lldb::LanguageType lang) { 398 static ConstString g_TypeHint("NSNumber:double"); 399 400 std::string prefix, suffix; 401 if (Language *language = Language::FindPlugin(lang)) { 402 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, 403 suffix)) { 404 prefix.clear(); 405 suffix.clear(); 406 } 407 } 408 409 stream.Printf("%s%g%s", prefix.c_str(), value, suffix.c_str()); 410 } 411 412 bool lldb_private::formatters::NSNumberSummaryProvider( 413 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 414 ProcessSP process_sp = valobj.GetProcessSP(); 415 if (!process_sp) 416 return false; 417 418 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 419 420 if (!runtime) 421 return false; 422 423 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 424 runtime->GetClassDescriptor(valobj)); 425 426 if (!descriptor || !descriptor->IsValid()) 427 return false; 428 429 uint32_t ptr_size = process_sp->GetAddressByteSize(); 430 431 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 432 433 if (!valobj_addr) 434 return false; 435 436 llvm::StringRef class_name(descriptor->GetClassName().GetCString()); 437 438 if (class_name.empty()) 439 return false; 440 441 if (class_name == "__NSCFBoolean") 442 return ObjCBooleanSummaryProvider(valobj, stream, options); 443 444 if (class_name == "NSDecimalNumber") 445 return NSDecimalNumberSummaryProvider(valobj, stream, options); 446 447 if (class_name == "NSNumber" || class_name == "__NSCFNumber") { 448 uint64_t value = 0; 449 uint64_t i_bits = 0; 450 if (descriptor->GetTaggedPointerInfo(&i_bits, &value)) { 451 switch (i_bits) { 452 case 0: 453 NSNumber_FormatChar(valobj, stream, (char)value, options.GetLanguage()); 454 break; 455 case 1: 456 case 4: 457 NSNumber_FormatShort(valobj, stream, (short)value, 458 options.GetLanguage()); 459 break; 460 case 2: 461 case 8: 462 NSNumber_FormatInt(valobj, stream, (int)value, options.GetLanguage()); 463 break; 464 case 3: 465 case 12: 466 NSNumber_FormatLong(valobj, stream, value, options.GetLanguage()); 467 break; 468 default: 469 return false; 470 } 471 return true; 472 } else { 473 Status error; 474 475 AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>( 476 ObjCLanguageRuntime::Get(*process_sp)); 477 478 const bool new_format = 479 (runtime && runtime->GetFoundationVersion() >= 1400); 480 481 enum class TypeCodes : int { 482 sint8 = 0x0, 483 sint16 = 0x1, 484 sint32 = 0x2, 485 sint64 = 0x3, 486 f32 = 0x4, 487 f64 = 0x5, 488 sint128 = 0x6 489 }; 490 491 uint64_t data_location = valobj_addr + 2 * ptr_size; 492 TypeCodes type_code; 493 494 if (new_format) { 495 uint64_t cfinfoa = 496 process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 497 ptr_size, 0, error); 498 499 if (error.Fail()) 500 return false; 501 502 bool is_preserved_number = cfinfoa & 0x8; 503 if (is_preserved_number) { 504 lldbassert(!static_cast<bool>("We should handle preserved numbers!")); 505 return false; 506 } 507 508 type_code = static_cast<TypeCodes>(cfinfoa & 0x7); 509 } else { 510 uint8_t data_type = 511 process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 1, 512 0, error) & 0x1F; 513 514 if (error.Fail()) 515 return false; 516 517 switch (data_type) { 518 case 1: type_code = TypeCodes::sint8; break; 519 case 2: type_code = TypeCodes::sint16; break; 520 case 3: type_code = TypeCodes::sint32; break; 521 case 17: data_location += 8; LLVM_FALLTHROUGH; 522 case 4: type_code = TypeCodes::sint64; break; 523 case 5: type_code = TypeCodes::f32; break; 524 case 6: type_code = TypeCodes::f64; break; 525 default: return false; 526 } 527 } 528 529 uint64_t value = 0; 530 bool success = false; 531 switch (type_code) { 532 case TypeCodes::sint8: 533 value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 1, 0, 534 error); 535 if (error.Fail()) 536 return false; 537 NSNumber_FormatChar(valobj, stream, (char)value, options.GetLanguage()); 538 success = true; 539 break; 540 case TypeCodes::sint16: 541 value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 2, 0, 542 error); 543 if (error.Fail()) 544 return false; 545 NSNumber_FormatShort(valobj, stream, (short)value, 546 options.GetLanguage()); 547 success = true; 548 break; 549 case TypeCodes::sint32: 550 value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, 551 error); 552 if (error.Fail()) 553 return false; 554 NSNumber_FormatInt(valobj, stream, (int)value, options.GetLanguage()); 555 success = true; 556 break; 557 case TypeCodes::sint64: 558 value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, 559 error); 560 if (error.Fail()) 561 return false; 562 NSNumber_FormatLong(valobj, stream, value, options.GetLanguage()); 563 success = true; 564 break; 565 case TypeCodes::f32: 566 { 567 uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory( 568 data_location, 4, 0, error); 569 if (error.Fail()) 570 return false; 571 float flt_value = 0.0f; 572 memcpy(&flt_value, &flt_as_int, sizeof(flt_as_int)); 573 NSNumber_FormatFloat(valobj, stream, flt_value, options.GetLanguage()); 574 success = true; 575 break; 576 } 577 case TypeCodes::f64: 578 { 579 uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory( 580 data_location, 8, 0, error); 581 if (error.Fail()) 582 return false; 583 double dbl_value = 0.0; 584 memcpy(&dbl_value, &dbl_as_lng, sizeof(dbl_as_lng)); 585 NSNumber_FormatDouble(valobj, stream, dbl_value, options.GetLanguage()); 586 success = true; 587 break; 588 } 589 case TypeCodes::sint128: // internally, this is the same 590 { 591 uint64_t words[2]; 592 words[1] = process_sp->ReadUnsignedIntegerFromMemory( 593 data_location, 8, 0, error); 594 if (error.Fail()) 595 return false; 596 words[0] = process_sp->ReadUnsignedIntegerFromMemory( 597 data_location + 8, 8, 0, error); 598 if (error.Fail()) 599 return false; 600 llvm::APInt i128_value(128, words); 601 NSNumber_FormatInt128(valobj, stream, i128_value, options.GetLanguage()); 602 success = true; 603 break; 604 } 605 } 606 return success; 607 } 608 } 609 610 return false; 611 } 612 613 bool lldb_private::formatters::NSDecimalNumberSummaryProvider( 614 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 615 ProcessSP process_sp = valobj.GetProcessSP(); 616 if (!process_sp) 617 return false; 618 619 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 620 uint32_t ptr_size = process_sp->GetAddressByteSize(); 621 622 Status error; 623 int8_t exponent = process_sp->ReadUnsignedIntegerFromMemory( 624 valobj_addr + ptr_size, 1, 0, error); 625 if (error.Fail()) 626 return false; 627 628 uint8_t length_and_negative = process_sp->ReadUnsignedIntegerFromMemory( 629 valobj_addr + ptr_size + 1, 1, 0, error); 630 if (error.Fail()) 631 return false; 632 633 // Fifth bit marks negativity. 634 const bool is_negative = (length_and_negative >> 4) & 1; 635 636 // Zero length and negative means NaN. 637 uint8_t length = length_and_negative & 0xf; 638 const bool is_nan = is_negative && (length == 0); 639 640 if (is_nan) { 641 stream.Printf("NaN"); 642 return true; 643 } 644 645 if (length == 0) { 646 stream.Printf("0"); 647 return true; 648 } 649 650 uint64_t mantissa = process_sp->ReadUnsignedIntegerFromMemory( 651 valobj_addr + ptr_size + 4, 8, 0, error); 652 if (error.Fail()) 653 return false; 654 655 if (is_negative) 656 stream.Printf("-"); 657 658 stream.Printf("%" PRIu64 " x 10^%" PRIi8, mantissa, exponent); 659 return true; 660 } 661 662 bool lldb_private::formatters::NSURLSummaryProvider( 663 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 664 ProcessSP process_sp = valobj.GetProcessSP(); 665 if (!process_sp) 666 return false; 667 668 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 669 670 if (!runtime) 671 return false; 672 673 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 674 runtime->GetClassDescriptor(valobj)); 675 676 if (!descriptor || !descriptor->IsValid()) 677 return false; 678 679 uint32_t ptr_size = process_sp->GetAddressByteSize(); 680 681 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 682 683 if (!valobj_addr) 684 return false; 685 686 llvm::StringRef class_name = descriptor->GetClassName().GetStringRef(); 687 688 if (!class_name.equals("NSURL")) 689 return false; 690 691 uint64_t offset_text = ptr_size + ptr_size + 692 8; // ISA + pointer + 8 bytes of data (even on 32bit) 693 uint64_t offset_base = offset_text + ptr_size; 694 CompilerType type(valobj.GetCompilerType()); 695 ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset_text, type, true)); 696 ValueObjectSP base(valobj.GetSyntheticChildAtOffset(offset_base, type, true)); 697 if (!text || text->GetValueAsUnsigned(0) == 0) 698 return false; 699 700 StreamString base_summary; 701 if (base && base->GetValueAsUnsigned(0)) { 702 if (!NSURLSummaryProvider(*base, base_summary, options)) 703 base_summary.Clear(); 704 } 705 if (base_summary.Empty()) 706 return NSStringSummaryProvider(*text, stream, options); 707 708 StreamString summary; 709 if (!NSStringSummaryProvider(*text, summary, options) || summary.Empty()) 710 return false; 711 712 const char quote_char = '"'; 713 std::string prefix, suffix; 714 if (Language *language = Language::FindPlugin(options.GetLanguage())) { 715 if (!language->GetFormatterPrefixSuffix(*text, ConstString("NSString"), 716 prefix, suffix)) { 717 prefix.clear(); 718 suffix.clear(); 719 } 720 } 721 // @"A" -> @"A 722 llvm::StringRef summary_str = summary.GetString(); 723 bool back_consumed = summary_str.consume_back(quote_char + suffix); 724 assert(back_consumed); 725 UNUSED_IF_ASSERT_DISABLED(back_consumed); 726 // @"B" -> B" 727 llvm::StringRef base_summary_str = base_summary.GetString(); 728 bool front_consumed = base_summary_str.consume_front(prefix + quote_char); 729 assert(front_consumed); 730 UNUSED_IF_ASSERT_DISABLED(front_consumed); 731 // @"A -- B" 732 if (!summary_str.empty() && !base_summary_str.empty()) { 733 stream.Printf("%s -- %s", summary_str.str().c_str(), 734 base_summary_str.str().c_str()); 735 return true; 736 } 737 738 return false; 739 } 740 741 /// Bias value for tagged pointer exponents. 742 /// Recommended values: 743 /// 0x3e3: encodes all dates between distantPast and distantFuture 744 /// except for the range within about 1e-28 second of the reference date. 745 /// 0x3ef: encodes all dates for a few million years beyond distantPast and 746 /// distantFuture, except within about 1e-25 second of the reference date. 747 const int TAGGED_DATE_EXPONENT_BIAS = 0x3ef; 748 749 struct DoubleBits { 750 uint64_t fraction : 52; // unsigned 751 uint64_t exponent : 11; // signed 752 uint64_t sign : 1; 753 }; 754 755 struct TaggedDoubleBits { 756 uint64_t fraction : 52; // unsigned 757 uint64_t exponent : 7; // signed 758 uint64_t sign : 1; 759 uint64_t unused : 4; // placeholder for pointer tag bits 760 }; 761 762 static uint64_t decodeExponent(uint64_t exp) { 763 // Tagged exponent field is 7-bit signed. Sign-extend the value to 64 bits 764 // before performing arithmetic. 765 return llvm::SignExtend64<7>(exp) + TAGGED_DATE_EXPONENT_BIAS; 766 } 767 768 static double decodeTaggedTimeInterval(uint64_t encodedTimeInterval) { 769 if (encodedTimeInterval == 0) 770 return 0.0; 771 if (encodedTimeInterval == std::numeric_limits<uint64_t>::max()) 772 return (uint64_t)-0.0; 773 774 TaggedDoubleBits encodedBits = 775 llvm::bit_cast<TaggedDoubleBits>(encodedTimeInterval); 776 assert(encodedBits.unused == 0); 777 778 // Sign and fraction are represented exactly. 779 // Exponent is encoded. 780 DoubleBits decodedBits; 781 decodedBits.sign = encodedBits.sign; 782 decodedBits.fraction = encodedBits.fraction; 783 decodedBits.exponent = decodeExponent(encodedBits.exponent); 784 785 return llvm::bit_cast<double>(decodedBits); 786 } 787 788 bool lldb_private::formatters::NSDateSummaryProvider( 789 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 790 ProcessSP process_sp = valobj.GetProcessSP(); 791 if (!process_sp) 792 return false; 793 794 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 795 796 if (!runtime) 797 return false; 798 799 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 800 runtime->GetClassDescriptor(valobj)); 801 802 if (!descriptor || !descriptor->IsValid()) 803 return false; 804 805 uint32_t ptr_size = process_sp->GetAddressByteSize(); 806 807 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 808 809 if (!valobj_addr) 810 return false; 811 812 uint64_t date_value_bits = 0; 813 double date_value = 0.0; 814 815 ConstString class_name = descriptor->GetClassName(); 816 817 static const ConstString g_NSDate("NSDate"); 818 static const ConstString g___NSDate("__NSDate"); 819 static const ConstString g___NSTaggedDate("__NSTaggedDate"); 820 static const ConstString g_NSCalendarDate("NSCalendarDate"); 821 822 if (class_name.IsEmpty()) 823 return false; 824 825 uint64_t info_bits = 0, value_bits = 0; 826 if ((class_name == g_NSDate) || (class_name == g___NSDate) || 827 (class_name == g___NSTaggedDate)) { 828 if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits)) { 829 date_value_bits = ((value_bits << 8) | (info_bits << 4)); 830 memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); 831 } else { 832 llvm::Triple triple( 833 process_sp->GetTarget().GetArchitecture().GetTriple()); 834 uint32_t delta = 835 (triple.isWatchOS() && triple.isWatchABI()) ? 8 : ptr_size; 836 Status error; 837 date_value_bits = process_sp->ReadUnsignedIntegerFromMemory( 838 valobj_addr + delta, 8, 0, error); 839 memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); 840 if (error.Fail()) 841 return false; 842 } 843 } else if (class_name == g_NSCalendarDate) { 844 Status error; 845 date_value_bits = process_sp->ReadUnsignedIntegerFromMemory( 846 valobj_addr + 2 * ptr_size, 8, 0, error); 847 memcpy(&date_value, &date_value_bits, sizeof(date_value_bits)); 848 if (error.Fail()) 849 return false; 850 } else 851 return false; 852 853 if (date_value == -63114076800) { 854 stream.Printf("0001-12-30 00:00:00 +0000"); 855 return true; 856 } 857 858 // Accomodate for the __NSTaggedDate format introduced in Foundation 1600. 859 if (class_name == g___NSTaggedDate) { 860 auto *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>( 861 ObjCLanguageRuntime::Get(*process_sp)); 862 if (runtime && runtime->GetFoundationVersion() >= 1600) 863 date_value = decodeTaggedTimeInterval(value_bits << 4); 864 } 865 866 // this snippet of code assumes that time_t == seconds since Jan-1-1970 this 867 // is generally true and POSIXly happy, but might break if a library vendor 868 // decides to get creative 869 time_t epoch = GetOSXEpoch(); 870 epoch = epoch + (time_t)date_value; 871 tm *tm_date = gmtime(&epoch); 872 if (!tm_date) 873 return false; 874 std::string buffer(1024, 0); 875 if (strftime(&buffer[0], 1023, "%Z", tm_date) == 0) 876 return false; 877 stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year + 1900, 878 tm_date->tm_mon + 1, tm_date->tm_mday, tm_date->tm_hour, 879 tm_date->tm_min, tm_date->tm_sec, buffer.c_str()); 880 return true; 881 } 882 883 bool lldb_private::formatters::ObjCClassSummaryProvider( 884 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 885 ProcessSP process_sp = valobj.GetProcessSP(); 886 if (!process_sp) 887 return false; 888 889 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 890 891 if (!runtime) 892 return false; 893 894 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 895 runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0))); 896 897 if (!descriptor || !descriptor->IsValid()) 898 return false; 899 900 ConstString class_name = descriptor->GetClassName(); 901 902 if (class_name.IsEmpty()) 903 return false; 904 905 if (ConstString cs = 906 Mangled(class_name).GetDemangledName(lldb::eLanguageTypeUnknown)) 907 class_name = cs; 908 909 stream.Printf("%s", class_name.AsCString("<unknown class>")); 910 return true; 911 } 912 913 class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd { 914 public: 915 ObjCClassSyntheticChildrenFrontEnd(lldb::ValueObjectSP valobj_sp) 916 : SyntheticChildrenFrontEnd(*valobj_sp) {} 917 918 ~ObjCClassSyntheticChildrenFrontEnd() override = default; 919 920 size_t CalculateNumChildren() override { return 0; } 921 922 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { 923 return lldb::ValueObjectSP(); 924 } 925 926 bool Update() override { return false; } 927 928 bool MightHaveChildren() override { return false; } 929 930 size_t GetIndexOfChildWithName(ConstString name) override { 931 return UINT32_MAX; 932 } 933 }; 934 935 SyntheticChildrenFrontEnd * 936 lldb_private::formatters::ObjCClassSyntheticFrontEndCreator( 937 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 938 return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp); 939 } 940 941 template <bool needs_at> 942 bool lldb_private::formatters::NSDataSummaryProvider( 943 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 944 ProcessSP process_sp = valobj.GetProcessSP(); 945 if (!process_sp) 946 return false; 947 948 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 949 950 if (!runtime) 951 return false; 952 953 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 954 runtime->GetClassDescriptor(valobj)); 955 956 if (!descriptor || !descriptor->IsValid()) 957 return false; 958 959 bool is_64bit = (process_sp->GetAddressByteSize() == 8); 960 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 961 962 if (!valobj_addr) 963 return false; 964 965 uint64_t value = 0; 966 967 llvm::StringRef class_name = descriptor->GetClassName().GetCString(); 968 969 if (class_name.empty()) 970 return false; 971 972 bool isNSConcreteData = class_name == "NSConcreteData"; 973 bool isNSConcreteMutableData = class_name == "NSConcreteMutableData"; 974 bool isNSCFData = class_name == "__NSCFData"; 975 if (isNSConcreteData || isNSConcreteMutableData || isNSCFData) { 976 uint32_t offset; 977 if (isNSConcreteData) 978 offset = is_64bit ? 8 : 4; 979 else 980 offset = is_64bit ? 16 : 8; 981 982 Status error; 983 value = process_sp->ReadUnsignedIntegerFromMemory( 984 valobj_addr + offset, is_64bit ? 8 : 4, 0, error); 985 if (error.Fail()) 986 return false; 987 } else if (class_name == "_NSInlineData") { 988 uint32_t offset = (is_64bit ? 8 : 4); 989 Status error; 990 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, 2, 991 0, error); 992 if (error.Fail()) 993 return false; 994 } else if (class_name == "_NSZeroData") { 995 value = 0; 996 } else 997 return false; 998 999 stream.Printf("%s%" PRIu64 " byte%s%s", (needs_at ? "@\"" : ""), value, 1000 (value != 1 ? "s" : ""), (needs_at ? "\"" : "")); 1001 1002 return true; 1003 } 1004 1005 bool lldb_private::formatters::ObjCBOOLSummaryProvider( 1006 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 1007 const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo(); 1008 1009 ValueObjectSP real_guy_sp = valobj.GetSP(); 1010 1011 if (type_info & eTypeIsPointer) { 1012 Status err; 1013 real_guy_sp = valobj.Dereference(err); 1014 if (err.Fail() || !real_guy_sp) 1015 return false; 1016 } else if (type_info & eTypeIsReference) { 1017 real_guy_sp = valobj.GetChildAtIndex(0, true); 1018 if (!real_guy_sp) 1019 return false; 1020 } 1021 uint8_t value = (real_guy_sp->GetValueAsUnsigned(0) & 0xFF); 1022 switch (value) { 1023 case 0: 1024 stream.Printf("NO"); 1025 break; 1026 case 1: 1027 stream.Printf("YES"); 1028 break; 1029 default: 1030 stream.Printf("%u", value); 1031 break; 1032 } 1033 return true; 1034 } 1035 1036 bool lldb_private::formatters::ObjCBooleanSummaryProvider( 1037 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 1038 lldb::addr_t valobj_ptr_value = 1039 valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 1040 if (valobj_ptr_value == LLDB_INVALID_ADDRESS) 1041 return false; 1042 1043 ProcessSP process_sp(valobj.GetProcessSP()); 1044 if (!process_sp) 1045 return false; 1046 1047 if (AppleObjCRuntime *objc_runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>( 1048 ObjCLanguageRuntime::Get(*process_sp))) { 1049 lldb::addr_t cf_true = LLDB_INVALID_ADDRESS, 1050 cf_false = LLDB_INVALID_ADDRESS; 1051 objc_runtime->GetValuesForGlobalCFBooleans(cf_true, cf_false); 1052 if (valobj_ptr_value == cf_true) { 1053 stream.PutCString("YES"); 1054 return true; 1055 } 1056 if (valobj_ptr_value == cf_false) { 1057 stream.PutCString("NO"); 1058 return true; 1059 } 1060 } 1061 1062 return false; 1063 } 1064 1065 template <bool is_sel_ptr> 1066 bool lldb_private::formatters::ObjCSELSummaryProvider( 1067 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 1068 lldb::ValueObjectSP valobj_sp; 1069 1070 CompilerType charstar(valobj.GetCompilerType() 1071 .GetBasicTypeFromAST(eBasicTypeChar) 1072 .GetPointerType()); 1073 1074 if (!charstar) 1075 return false; 1076 1077 ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); 1078 1079 if (is_sel_ptr) { 1080 lldb::addr_t data_address = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 1081 if (data_address == LLDB_INVALID_ADDRESS) 1082 return false; 1083 valobj_sp = ValueObject::CreateValueObjectFromAddress("text", data_address, 1084 exe_ctx, charstar); 1085 } else { 1086 DataExtractor data; 1087 Status error; 1088 valobj.GetData(data, error); 1089 if (error.Fail()) 1090 return false; 1091 valobj_sp = 1092 ValueObject::CreateValueObjectFromData("text", data, exe_ctx, charstar); 1093 } 1094 1095 if (!valobj_sp) 1096 return false; 1097 1098 stream.Printf("%s", valobj_sp->GetSummaryAsCString()); 1099 return true; 1100 } 1101 1102 // POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001 1103 // this call gives the POSIX equivalent of the Cocoa epoch 1104 time_t lldb_private::formatters::GetOSXEpoch() { 1105 static time_t epoch = 0; 1106 if (!epoch) { 1107 #ifndef _WIN32 1108 tzset(); 1109 tm tm_epoch; 1110 tm_epoch.tm_sec = 0; 1111 tm_epoch.tm_hour = 0; 1112 tm_epoch.tm_min = 0; 1113 tm_epoch.tm_mon = 0; 1114 tm_epoch.tm_mday = 1; 1115 tm_epoch.tm_year = 2001 - 1900; 1116 tm_epoch.tm_isdst = -1; 1117 tm_epoch.tm_gmtoff = 0; 1118 tm_epoch.tm_zone = nullptr; 1119 epoch = timegm(&tm_epoch); 1120 #endif 1121 } 1122 return epoch; 1123 } 1124 1125 template bool lldb_private::formatters::NSDataSummaryProvider<true>( 1126 ValueObject &, Stream &, const TypeSummaryOptions &); 1127 1128 template bool lldb_private::formatters::NSDataSummaryProvider<false>( 1129 ValueObject &, Stream &, const TypeSummaryOptions &); 1130 1131 template bool lldb_private::formatters::ObjCSELSummaryProvider<true>( 1132 ValueObject &, Stream &, const TypeSummaryOptions &); 1133 1134 template bool lldb_private::formatters::ObjCSELSummaryProvider<false>( 1135 ValueObject &, Stream &, const TypeSummaryOptions &); 1136