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

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