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