xref: /freebsd-11-stable/contrib/llvm-project/lldb/source/Plugins/Language/ObjC/Cocoa.cpp (revision 9d1b76e2786478cdef6a403311925c92899640b8) 
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 
NSBundleSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSTimeZoneSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSNotificationSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSMachPortSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSIndexSetSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSNumber_FormatChar(ValueObject & valobj,Stream & stream,char value,lldb::LanguageType lang)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 
NSNumber_FormatShort(ValueObject & valobj,Stream & stream,short value,lldb::LanguageType lang)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 
NSNumber_FormatInt(ValueObject & valobj,Stream & stream,int value,lldb::LanguageType lang)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 
NSNumber_FormatLong(ValueObject & valobj,Stream & stream,uint64_t value,lldb::LanguageType lang)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 
NSNumber_FormatInt128(ValueObject & valobj,Stream & stream,const llvm::APInt & value,lldb::LanguageType lang)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 
NSNumber_FormatFloat(ValueObject & valobj,Stream & stream,float value,lldb::LanguageType lang)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 
NSNumber_FormatDouble(ValueObject & valobj,Stream & stream,double value,lldb::LanguageType lang)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 
NSNumberSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSDecimalNumberSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 
NSURLSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)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 || text->GetValueAsUnsigned(0) == 0)
698     return false;
699 
700   StreamString base_summary;
701   if (base && base->GetValueAsUnsigned(0)) {
702     if (!NSURLSummaryProvider(*base, base_summary, options))
703       base_summary.Clear();
704   }
705   if (base_summary.Empty())
706     return NSStringSummaryProvider(*text, stream, options);
707 
708   StreamString summary;
709   if (!NSStringSummaryProvider(*text, summary, options) || summary.Empty())
710     return false;
711 
712   const char quote_char = '"';
713   std::string prefix, suffix;
714   if (Language *language = Language::FindPlugin(options.GetLanguage())) {
715     if (!language->GetFormatterPrefixSuffix(*text, ConstString("NSString"),
716                                             prefix, suffix)) {
717       prefix.clear();
718       suffix.clear();
719     }
720   }
721   // @"A" -> @"A
722   llvm::StringRef summary_str = summary.GetString();
723   bool back_consumed = summary_str.consume_back(quote_char + suffix);
724   assert(back_consumed);
725   UNUSED_IF_ASSERT_DISABLED(back_consumed);
726   // @"B" -> B"
727   llvm::StringRef base_summary_str = base_summary.GetString();
728   bool front_consumed = base_summary_str.consume_front(prefix + quote_char);
729   assert(front_consumed);
730   UNUSED_IF_ASSERT_DISABLED(front_consumed);
731   // @"A -- B"
732   if (!summary_str.empty() && !base_summary_str.empty()) {
733     stream.Printf("%s -- %s", summary_str.str().c_str(),
734                   base_summary_str.str().c_str());
735     return true;
736   }
737 
738   return false;
739 }
740 
741 /// Bias value for tagged pointer exponents.
742 /// Recommended values:
743 /// 0x3e3: encodes all dates between distantPast and distantFuture
744 ///   except for the range within about 1e-28 second of the reference date.
745 /// 0x3ef: encodes all dates for a few million years beyond distantPast and
746 ///   distantFuture, except within about 1e-25 second of the reference date.
747 const int TAGGED_DATE_EXPONENT_BIAS = 0x3ef;
748 
749 struct DoubleBits {
750   uint64_t fraction : 52; // unsigned
751   uint64_t exponent : 11; // signed
752   uint64_t sign : 1;
753 };
754 
755 struct TaggedDoubleBits {
756   uint64_t fraction : 52; // unsigned
757   uint64_t exponent : 7;  // signed
758   uint64_t sign : 1;
759   uint64_t unused : 4; // placeholder for pointer tag bits
760 };
761 
decodeExponent(uint64_t exp)762 static uint64_t decodeExponent(uint64_t exp) {
763   // Tagged exponent field is 7-bit signed. Sign-extend the value to 64 bits
764   // before performing arithmetic.
765   return llvm::SignExtend64<7>(exp) + TAGGED_DATE_EXPONENT_BIAS;
766 }
767 
decodeTaggedTimeInterval(uint64_t encodedTimeInterval)768 static double decodeTaggedTimeInterval(uint64_t encodedTimeInterval) {
769   if (encodedTimeInterval == 0)
770     return 0.0;
771   if (encodedTimeInterval == std::numeric_limits<uint64_t>::max())
772     return (uint64_t)-0.0;
773 
774   TaggedDoubleBits encodedBits =
775       llvm::bit_cast<TaggedDoubleBits>(encodedTimeInterval);
776   assert(encodedBits.unused == 0);
777 
778   // Sign and fraction are represented exactly.
779   // Exponent is encoded.
780   DoubleBits decodedBits;
781   decodedBits.sign = encodedBits.sign;
782   decodedBits.fraction = encodedBits.fraction;
783   decodedBits.exponent = decodeExponent(encodedBits.exponent);
784 
785   return llvm::bit_cast<double>(decodedBits);
786 }
787 
NSDateSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)788 bool lldb_private::formatters::NSDateSummaryProvider(
789     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
790   ProcessSP process_sp = valobj.GetProcessSP();
791   if (!process_sp)
792     return false;
793 
794   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
795 
796   if (!runtime)
797     return false;
798 
799   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
800       runtime->GetClassDescriptor(valobj));
801 
802   if (!descriptor || !descriptor->IsValid())
803     return false;
804 
805   uint32_t ptr_size = process_sp->GetAddressByteSize();
806 
807   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
808 
809   if (!valobj_addr)
810     return false;
811 
812   uint64_t date_value_bits = 0;
813   double date_value = 0.0;
814 
815   ConstString class_name = descriptor->GetClassName();
816 
817   static const ConstString g_NSDate("NSDate");
818   static const ConstString g___NSDate("__NSDate");
819   static const ConstString g___NSTaggedDate("__NSTaggedDate");
820   static const ConstString g_NSCalendarDate("NSCalendarDate");
821 
822   if (class_name.IsEmpty())
823     return false;
824 
825   uint64_t info_bits = 0, value_bits = 0;
826   if ((class_name == g_NSDate) || (class_name == g___NSDate) ||
827       (class_name == g___NSTaggedDate)) {
828     if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits)) {
829       date_value_bits = ((value_bits << 8) | (info_bits << 4));
830       memcpy(&date_value, &date_value_bits, sizeof(date_value_bits));
831     } else {
832       llvm::Triple triple(
833           process_sp->GetTarget().GetArchitecture().GetTriple());
834       uint32_t delta =
835           (triple.isWatchOS() && triple.isWatchABI()) ? 8 : ptr_size;
836       Status error;
837       date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(
838           valobj_addr + delta, 8, 0, error);
839       memcpy(&date_value, &date_value_bits, sizeof(date_value_bits));
840       if (error.Fail())
841         return false;
842     }
843   } else if (class_name == g_NSCalendarDate) {
844     Status error;
845     date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(
846         valobj_addr + 2 * ptr_size, 8, 0, error);
847     memcpy(&date_value, &date_value_bits, sizeof(date_value_bits));
848     if (error.Fail())
849       return false;
850   } else
851     return false;
852 
853   if (date_value == -63114076800) {
854     stream.Printf("0001-12-30 00:00:00 +0000");
855     return true;
856   }
857 
858   // Accomodate for the __NSTaggedDate format introduced in Foundation 1600.
859   if (class_name == g___NSTaggedDate) {
860     auto *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
861         ObjCLanguageRuntime::Get(*process_sp));
862     if (runtime && runtime->GetFoundationVersion() >= 1600)
863       date_value = decodeTaggedTimeInterval(value_bits << 4);
864   }
865 
866   // this snippet of code assumes that time_t == seconds since Jan-1-1970 this
867   // is generally true and POSIXly happy, but might break if a library vendor
868   // decides to get creative
869   time_t epoch = GetOSXEpoch();
870   epoch = epoch + (time_t)date_value;
871   tm *tm_date = gmtime(&epoch);
872   if (!tm_date)
873     return false;
874   std::string buffer(1024, 0);
875   if (strftime(&buffer[0], 1023, "%Z", tm_date) == 0)
876     return false;
877   stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year + 1900,
878                 tm_date->tm_mon + 1, tm_date->tm_mday, tm_date->tm_hour,
879                 tm_date->tm_min, tm_date->tm_sec, buffer.c_str());
880   return true;
881 }
882 
ObjCClassSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)883 bool lldb_private::formatters::ObjCClassSummaryProvider(
884     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
885   ProcessSP process_sp = valobj.GetProcessSP();
886   if (!process_sp)
887     return false;
888 
889   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
890 
891   if (!runtime)
892     return false;
893 
894   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
895       runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0)));
896 
897   if (!descriptor || !descriptor->IsValid())
898     return false;
899 
900   ConstString class_name = descriptor->GetClassName();
901 
902   if (class_name.IsEmpty())
903     return false;
904 
905   if (ConstString cs =
906           Mangled(class_name).GetDemangledName(lldb::eLanguageTypeUnknown))
907     class_name = cs;
908 
909   stream.Printf("%s", class_name.AsCString("<unknown class>"));
910   return true;
911 }
912 
913 class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd {
914 public:
ObjCClassSyntheticChildrenFrontEnd(lldb::ValueObjectSP valobj_sp)915   ObjCClassSyntheticChildrenFrontEnd(lldb::ValueObjectSP valobj_sp)
916       : SyntheticChildrenFrontEnd(*valobj_sp) {}
917 
918   ~ObjCClassSyntheticChildrenFrontEnd() override = default;
919 
CalculateNumChildren()920   size_t CalculateNumChildren() override { return 0; }
921 
GetChildAtIndex(size_t idx)922   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
923     return lldb::ValueObjectSP();
924   }
925 
Update()926   bool Update() override { return false; }
927 
MightHaveChildren()928   bool MightHaveChildren() override { return false; }
929 
GetIndexOfChildWithName(ConstString name)930   size_t GetIndexOfChildWithName(ConstString name) override {
931     return UINT32_MAX;
932   }
933 };
934 
935 SyntheticChildrenFrontEnd *
ObjCClassSyntheticFrontEndCreator(CXXSyntheticChildren *,lldb::ValueObjectSP valobj_sp)936 lldb_private::formatters::ObjCClassSyntheticFrontEndCreator(
937     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
938   return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp);
939 }
940 
941 template <bool needs_at>
NSDataSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)942 bool lldb_private::formatters::NSDataSummaryProvider(
943     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
944   ProcessSP process_sp = valobj.GetProcessSP();
945   if (!process_sp)
946     return false;
947 
948   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
949 
950   if (!runtime)
951     return false;
952 
953   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
954       runtime->GetClassDescriptor(valobj));
955 
956   if (!descriptor || !descriptor->IsValid())
957     return false;
958 
959   bool is_64bit = (process_sp->GetAddressByteSize() == 8);
960   lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
961 
962   if (!valobj_addr)
963     return false;
964 
965   uint64_t value = 0;
966 
967   llvm::StringRef class_name = descriptor->GetClassName().GetCString();
968 
969   if (class_name.empty())
970     return false;
971 
972   bool isNSConcreteData = class_name == "NSConcreteData";
973   bool isNSConcreteMutableData = class_name == "NSConcreteMutableData";
974   bool isNSCFData = class_name == "__NSCFData";
975   if (isNSConcreteData || isNSConcreteMutableData || isNSCFData) {
976     uint32_t offset;
977     if (isNSConcreteData)
978       offset = is_64bit ? 8 : 4;
979     else
980       offset = is_64bit ? 16 : 8;
981 
982     Status error;
983     value = process_sp->ReadUnsignedIntegerFromMemory(
984         valobj_addr + offset, is_64bit ? 8 : 4, 0, error);
985     if (error.Fail())
986       return false;
987   } else if (class_name == "_NSInlineData") {
988     uint32_t offset = (is_64bit ? 8 : 4);
989     Status error;
990     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, 2,
991                                                       0, error);
992     if (error.Fail())
993       return false;
994   } else if (class_name == "_NSZeroData") {
995     value = 0;
996   } else
997     return false;
998 
999   stream.Printf("%s%" PRIu64 " byte%s%s", (needs_at ? "@\"" : ""), value,
1000                 (value != 1 ? "s" : ""), (needs_at ? "\"" : ""));
1001 
1002   return true;
1003 }
1004 
ObjCBOOLSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)1005 bool lldb_private::formatters::ObjCBOOLSummaryProvider(
1006     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
1007   const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo();
1008 
1009   ValueObjectSP real_guy_sp = valobj.GetSP();
1010 
1011   if (type_info & eTypeIsPointer) {
1012     Status err;
1013     real_guy_sp = valobj.Dereference(err);
1014     if (err.Fail() || !real_guy_sp)
1015       return false;
1016   } else if (type_info & eTypeIsReference) {
1017     real_guy_sp = valobj.GetChildAtIndex(0, true);
1018     if (!real_guy_sp)
1019       return false;
1020   }
1021   uint8_t value = (real_guy_sp->GetValueAsUnsigned(0) & 0xFF);
1022   switch (value) {
1023   case 0:
1024     stream.Printf("NO");
1025     break;
1026   case 1:
1027     stream.Printf("YES");
1028     break;
1029   default:
1030     stream.Printf("%u", value);
1031     break;
1032   }
1033   return true;
1034 }
1035 
ObjCBooleanSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)1036 bool lldb_private::formatters::ObjCBooleanSummaryProvider(
1037     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
1038   lldb::addr_t valobj_ptr_value =
1039       valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
1040   if (valobj_ptr_value == LLDB_INVALID_ADDRESS)
1041     return false;
1042 
1043   ProcessSP process_sp(valobj.GetProcessSP());
1044   if (!process_sp)
1045     return false;
1046 
1047   if (AppleObjCRuntime *objc_runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
1048           ObjCLanguageRuntime::Get(*process_sp))) {
1049     lldb::addr_t cf_true = LLDB_INVALID_ADDRESS,
1050                  cf_false = LLDB_INVALID_ADDRESS;
1051     objc_runtime->GetValuesForGlobalCFBooleans(cf_true, cf_false);
1052     if (valobj_ptr_value == cf_true) {
1053       stream.PutCString("YES");
1054       return true;
1055     }
1056     if (valobj_ptr_value == cf_false) {
1057       stream.PutCString("NO");
1058       return true;
1059     }
1060   }
1061 
1062   return false;
1063 }
1064 
1065 template <bool is_sel_ptr>
ObjCSELSummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)1066 bool lldb_private::formatters::ObjCSELSummaryProvider(
1067     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
1068   lldb::ValueObjectSP valobj_sp;
1069 
1070   CompilerType charstar(valobj.GetCompilerType()
1071                             .GetBasicTypeFromAST(eBasicTypeChar)
1072                             .GetPointerType());
1073 
1074   if (!charstar)
1075     return false;
1076 
1077   ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
1078 
1079   if (is_sel_ptr) {
1080     lldb::addr_t data_address = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
1081     if (data_address == LLDB_INVALID_ADDRESS)
1082       return false;
1083     valobj_sp = ValueObject::CreateValueObjectFromAddress("text", data_address,
1084                                                           exe_ctx, charstar);
1085   } else {
1086     DataExtractor data;
1087     Status error;
1088     valobj.GetData(data, error);
1089     if (error.Fail())
1090       return false;
1091     valobj_sp =
1092         ValueObject::CreateValueObjectFromData("text", data, exe_ctx, charstar);
1093   }
1094 
1095   if (!valobj_sp)
1096     return false;
1097 
1098   stream.Printf("%s", valobj_sp->GetSummaryAsCString());
1099   return true;
1100 }
1101 
1102 // POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001
1103 // this call gives the POSIX equivalent of the Cocoa epoch
GetOSXEpoch()1104 time_t lldb_private::formatters::GetOSXEpoch() {
1105   static time_t epoch = 0;
1106   if (!epoch) {
1107 #ifndef _WIN32
1108     tzset();
1109     tm tm_epoch;
1110     tm_epoch.tm_sec = 0;
1111     tm_epoch.tm_hour = 0;
1112     tm_epoch.tm_min = 0;
1113     tm_epoch.tm_mon = 0;
1114     tm_epoch.tm_mday = 1;
1115     tm_epoch.tm_year = 2001 - 1900;
1116     tm_epoch.tm_isdst = -1;
1117     tm_epoch.tm_gmtoff = 0;
1118     tm_epoch.tm_zone = nullptr;
1119     epoch = timegm(&tm_epoch);
1120 #endif
1121   }
1122   return epoch;
1123 }
1124 
1125 template bool lldb_private::formatters::NSDataSummaryProvider<true>(
1126     ValueObject &, Stream &, const TypeSummaryOptions &);
1127 
1128 template bool lldb_private::formatters::NSDataSummaryProvider<false>(
1129     ValueObject &, Stream &, const TypeSummaryOptions &);
1130 
1131 template bool lldb_private::formatters::ObjCSELSummaryProvider<true>(
1132     ValueObject &, Stream &, const TypeSummaryOptions &);
1133 
1134 template bool lldb_private::formatters::ObjCSELSummaryProvider<false>(
1135     ValueObject &, Stream &, const TypeSummaryOptions &);
1136