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