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 &);
1094