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