1 //===-- AppleObjCClassDescriptorV2.cpp ------------------------------------===//
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 "AppleObjCClassDescriptorV2.h"
10 
11 #include "lldb/Expression/FunctionCaller.h"
12 #include "lldb/Target/ABI.h"
13 #include "lldb/Target/Language.h"
14 #include "lldb/Utility/LLDBLog.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/lldb-enumerations.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 bool ClassDescriptorV2::Read_objc_class(
22     Process *process, std::unique_ptr<objc_class_t> &objc_class) const {
23   objc_class = std::make_unique<objc_class_t>();
24 
25   bool ret = objc_class->Read(process, m_objc_class_ptr);
26 
27   if (!ret)
28     objc_class.reset();
29 
30   return ret;
31 }
32 
33 static lldb::addr_t GetClassDataMask(Process *process) {
34   switch (process->GetAddressByteSize()) {
35   case 4:
36     return 0xfffffffcUL;
37   case 8:
38     return 0x00007ffffffffff8UL;
39   default:
40     break;
41   }
42 
43   return LLDB_INVALID_ADDRESS;
44 }
45 
46 bool ClassDescriptorV2::objc_class_t::Read(Process *process,
47                                            lldb::addr_t addr) {
48   size_t ptr_size = process->GetAddressByteSize();
49 
50   size_t objc_class_size = ptr_size    // uintptr_t isa;
51                            + ptr_size  // Class superclass;
52                            + ptr_size  // void *cache;
53                            + ptr_size  // IMP *vtable;
54                            + ptr_size; // uintptr_t data_NEVER_USE;
55 
56   DataBufferHeap objc_class_buf(objc_class_size, '\0');
57   Status error;
58 
59   process->ReadMemory(addr, objc_class_buf.GetBytes(), objc_class_size, error);
60   if (error.Fail()) {
61     return false;
62   }
63 
64   DataExtractor extractor(objc_class_buf.GetBytes(), objc_class_size,
65                           process->GetByteOrder(),
66                           process->GetAddressByteSize());
67 
68   lldb::offset_t cursor = 0;
69 
70   m_isa = extractor.GetAddress_unchecked(&cursor);        // uintptr_t isa;
71   m_superclass = extractor.GetAddress_unchecked(&cursor); // Class superclass;
72   m_cache_ptr = extractor.GetAddress_unchecked(&cursor);  // void *cache;
73   m_vtable_ptr = extractor.GetAddress_unchecked(&cursor); // IMP *vtable;
74   lldb::addr_t data_NEVER_USE =
75       extractor.GetAddress_unchecked(&cursor); // uintptr_t data_NEVER_USE;
76 
77   m_flags = (uint8_t)(data_NEVER_USE & (lldb::addr_t)3);
78   m_data_ptr = data_NEVER_USE & GetClassDataMask(process);
79 
80   if (ABISP abi_sp = process->GetABI()) {
81     m_isa = abi_sp->FixCodeAddress(m_isa);
82     m_superclass = abi_sp->FixCodeAddress(m_superclass);
83     m_data_ptr = abi_sp->FixCodeAddress(m_data_ptr);
84   }
85   return true;
86 }
87 
88 bool ClassDescriptorV2::class_rw_t::Read(Process *process, lldb::addr_t addr) {
89   size_t ptr_size = process->GetAddressByteSize();
90 
91   size_t size = sizeof(uint32_t)   // uint32_t flags;
92                 + sizeof(uint32_t) // uint32_t version;
93                 + ptr_size         // const class_ro_t *ro;
94                 + ptr_size         // union { method_list_t **method_lists;
95                                    // method_list_t *method_list; };
96                 + ptr_size         // struct chained_property_list *properties;
97                 + ptr_size         // const protocol_list_t **protocols;
98                 + ptr_size         // Class firstSubclass;
99                 + ptr_size;        // Class nextSiblingClass;
100 
101   DataBufferHeap buffer(size, '\0');
102   Status error;
103 
104   process->ReadMemory(addr, buffer.GetBytes(), size, error);
105   if (error.Fail()) {
106     return false;
107   }
108 
109   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
110                           process->GetAddressByteSize());
111 
112   lldb::offset_t cursor = 0;
113 
114   m_flags = extractor.GetU32_unchecked(&cursor);
115   m_version = extractor.GetU32_unchecked(&cursor);
116   m_ro_ptr = extractor.GetAddress_unchecked(&cursor);
117   if (ABISP abi_sp = process->GetABI())
118     m_ro_ptr = abi_sp->FixCodeAddress(m_ro_ptr);
119   m_method_list_ptr = extractor.GetAddress_unchecked(&cursor);
120   m_properties_ptr = extractor.GetAddress_unchecked(&cursor);
121   m_firstSubclass = extractor.GetAddress_unchecked(&cursor);
122   m_nextSiblingClass = extractor.GetAddress_unchecked(&cursor);
123 
124   if (m_ro_ptr & 1) {
125     DataBufferHeap buffer(ptr_size, '\0');
126     process->ReadMemory(m_ro_ptr ^ 1, buffer.GetBytes(), ptr_size, error);
127     if (error.Fail())
128       return false;
129     cursor = 0;
130     DataExtractor extractor(buffer.GetBytes(), ptr_size,
131                             process->GetByteOrder(),
132                             process->GetAddressByteSize());
133     m_ro_ptr = extractor.GetAddress_unchecked(&cursor);
134     if (ABISP abi_sp = process->GetABI())
135       m_ro_ptr = abi_sp->FixCodeAddress(m_ro_ptr);
136   }
137 
138   return true;
139 }
140 
141 bool ClassDescriptorV2::class_ro_t::Read(Process *process, lldb::addr_t addr) {
142   size_t ptr_size = process->GetAddressByteSize();
143 
144   size_t size = sizeof(uint32_t)   // uint32_t flags;
145                 + sizeof(uint32_t) // uint32_t instanceStart;
146                 + sizeof(uint32_t) // uint32_t instanceSize;
147                 + (ptr_size == 8 ? sizeof(uint32_t)
148                                  : 0) // uint32_t reserved; // __LP64__ only
149                 + ptr_size            // const uint8_t *ivarLayout;
150                 + ptr_size            // const char *name;
151                 + ptr_size            // const method_list_t *baseMethods;
152                 + ptr_size            // const protocol_list_t *baseProtocols;
153                 + ptr_size            // const ivar_list_t *ivars;
154                 + ptr_size            // const uint8_t *weakIvarLayout;
155                 + ptr_size;           // const property_list_t *baseProperties;
156 
157   DataBufferHeap buffer(size, '\0');
158   Status error;
159 
160   process->ReadMemory(addr, buffer.GetBytes(), size, error);
161   if (error.Fail()) {
162     return false;
163   }
164 
165   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
166                           process->GetAddressByteSize());
167 
168   lldb::offset_t cursor = 0;
169 
170   m_flags = extractor.GetU32_unchecked(&cursor);
171   m_instanceStart = extractor.GetU32_unchecked(&cursor);
172   m_instanceSize = extractor.GetU32_unchecked(&cursor);
173   if (ptr_size == 8)
174     m_reserved = extractor.GetU32_unchecked(&cursor);
175   else
176     m_reserved = 0;
177   m_ivarLayout_ptr = extractor.GetAddress_unchecked(&cursor);
178   m_name_ptr = extractor.GetAddress_unchecked(&cursor);
179   m_baseMethods_ptr = extractor.GetAddress_unchecked(&cursor);
180   m_baseProtocols_ptr = extractor.GetAddress_unchecked(&cursor);
181   m_ivars_ptr = extractor.GetAddress_unchecked(&cursor);
182   m_weakIvarLayout_ptr = extractor.GetAddress_unchecked(&cursor);
183   m_baseProperties_ptr = extractor.GetAddress_unchecked(&cursor);
184 
185   DataBufferHeap name_buf(1024, '\0');
186 
187   process->ReadCStringFromMemory(m_name_ptr, (char *)name_buf.GetBytes(),
188                                  name_buf.GetByteSize(), error);
189 
190   if (error.Fail()) {
191     return false;
192   }
193 
194   m_name.assign((char *)name_buf.GetBytes());
195 
196   return true;
197 }
198 
199 bool ClassDescriptorV2::Read_class_row(
200     Process *process, const objc_class_t &objc_class,
201     std::unique_ptr<class_ro_t> &class_ro,
202     std::unique_ptr<class_rw_t> &class_rw) const {
203   class_ro.reset();
204   class_rw.reset();
205 
206   Status error;
207   uint32_t class_row_t_flags = process->ReadUnsignedIntegerFromMemory(
208       objc_class.m_data_ptr, sizeof(uint32_t), 0, error);
209   if (!error.Success())
210     return false;
211 
212   if (class_row_t_flags & RW_REALIZED) {
213     class_rw = std::make_unique<class_rw_t>();
214 
215     if (!class_rw->Read(process, objc_class.m_data_ptr)) {
216       class_rw.reset();
217       return false;
218     }
219 
220     class_ro = std::make_unique<class_ro_t>();
221 
222     if (!class_ro->Read(process, class_rw->m_ro_ptr)) {
223       class_rw.reset();
224       class_ro.reset();
225       return false;
226     }
227   } else {
228     class_ro = std::make_unique<class_ro_t>();
229 
230     if (!class_ro->Read(process, objc_class.m_data_ptr)) {
231       class_ro.reset();
232       return false;
233     }
234   }
235 
236   return true;
237 }
238 
239 bool ClassDescriptorV2::method_list_t::Read(Process *process,
240                                             lldb::addr_t addr) {
241   size_t size = sizeof(uint32_t)    // uint32_t entsize_NEVER_USE;
242                 + sizeof(uint32_t); // uint32_t count;
243 
244   DataBufferHeap buffer(size, '\0');
245   Status error;
246 
247   if (ABISP abi_sp = process->GetABI())
248     addr = abi_sp->FixCodeAddress(addr);
249   process->ReadMemory(addr, buffer.GetBytes(), size, error);
250   if (error.Fail()) {
251     return false;
252   }
253 
254   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
255                           process->GetAddressByteSize());
256 
257   lldb::offset_t cursor = 0;
258 
259   uint32_t entsize = extractor.GetU32_unchecked(&cursor);
260   m_is_small = (entsize & 0x80000000) != 0;
261   m_has_direct_selector = (entsize & 0x40000000) != 0;
262   m_entsize = entsize & 0xfffc;
263   m_count = extractor.GetU32_unchecked(&cursor);
264   m_first_ptr = addr + cursor;
265 
266   return true;
267 }
268 
269 bool ClassDescriptorV2::method_t::Read(Process *process, lldb::addr_t addr,
270                                        lldb::addr_t relative_selector_base_addr,
271                                        bool is_small, bool has_direct_sel) {
272   size_t ptr_size = process->GetAddressByteSize();
273   size_t size = GetSize(process, is_small);
274 
275   DataBufferHeap buffer(size, '\0');
276   Status error;
277 
278   process->ReadMemory(addr, buffer.GetBytes(), size, error);
279   if (error.Fail()) {
280     return false;
281   }
282 
283   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
284                           ptr_size);
285   lldb::offset_t cursor = 0;
286 
287   if (is_small) {
288     uint32_t nameref_offset = extractor.GetU32_unchecked(&cursor);
289     uint32_t types_offset = extractor.GetU32_unchecked(&cursor);
290     uint32_t imp_offset = extractor.GetU32_unchecked(&cursor);
291 
292     m_name_ptr = addr + nameref_offset;
293 
294     if (!has_direct_sel) {
295       // The SEL offset points to a SELRef. We need to dereference twice.
296       m_name_ptr = process->ReadUnsignedIntegerFromMemory(m_name_ptr, ptr_size,
297                                                           0, error);
298       if (!error.Success())
299         return false;
300     } else if (relative_selector_base_addr != LLDB_INVALID_ADDRESS) {
301       m_name_ptr = relative_selector_base_addr + nameref_offset;
302     }
303     m_types_ptr = addr + 4 + types_offset;
304     m_imp_ptr = addr + 8 + imp_offset;
305   } else {
306     m_name_ptr = extractor.GetAddress_unchecked(&cursor);
307     m_types_ptr = extractor.GetAddress_unchecked(&cursor);
308     m_imp_ptr = extractor.GetAddress_unchecked(&cursor);
309   }
310 
311   process->ReadCStringFromMemory(m_name_ptr, m_name, error);
312   if (error.Fail()) {
313     return false;
314   }
315 
316   process->ReadCStringFromMemory(m_types_ptr, m_types, error);
317   return !error.Fail();
318 }
319 
320 bool ClassDescriptorV2::ivar_list_t::Read(Process *process, lldb::addr_t addr) {
321   size_t size = sizeof(uint32_t)    // uint32_t entsize;
322                 + sizeof(uint32_t); // uint32_t count;
323 
324   DataBufferHeap buffer(size, '\0');
325   Status error;
326 
327   process->ReadMemory(addr, buffer.GetBytes(), size, error);
328   if (error.Fail()) {
329     return false;
330   }
331 
332   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
333                           process->GetAddressByteSize());
334 
335   lldb::offset_t cursor = 0;
336 
337   m_entsize = extractor.GetU32_unchecked(&cursor);
338   m_count = extractor.GetU32_unchecked(&cursor);
339   m_first_ptr = addr + cursor;
340 
341   return true;
342 }
343 
344 bool ClassDescriptorV2::ivar_t::Read(Process *process, lldb::addr_t addr) {
345   size_t size = GetSize(process);
346 
347   DataBufferHeap buffer(size, '\0');
348   Status error;
349 
350   process->ReadMemory(addr, buffer.GetBytes(), size, error);
351   if (error.Fail()) {
352     return false;
353   }
354 
355   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
356                           process->GetAddressByteSize());
357 
358   lldb::offset_t cursor = 0;
359 
360   m_offset_ptr = extractor.GetAddress_unchecked(&cursor);
361   m_name_ptr = extractor.GetAddress_unchecked(&cursor);
362   m_type_ptr = extractor.GetAddress_unchecked(&cursor);
363   m_alignment = extractor.GetU32_unchecked(&cursor);
364   m_size = extractor.GetU32_unchecked(&cursor);
365 
366   process->ReadCStringFromMemory(m_name_ptr, m_name, error);
367   if (error.Fail()) {
368     return false;
369   }
370 
371   process->ReadCStringFromMemory(m_type_ptr, m_type, error);
372   return !error.Fail();
373 }
374 
375 bool ClassDescriptorV2::relative_list_entry_t::Read(Process *process,
376                                                     lldb::addr_t addr) {
377   Log *log = GetLog(LLDBLog::Types);
378   size_t size = sizeof(uint64_t); // m_image_index : 16
379                                   // m_list_offset : 48
380 
381   DataBufferHeap buffer(size, '\0');
382   Status error;
383 
384   process->ReadMemory(addr, buffer.GetBytes(), size, error);
385   // FIXME: Propagate this error up
386   if (error.Fail()) {
387     LLDB_LOG(log, "Failed to read relative_list_entry_t at address {0:x}",
388              addr);
389     return false;
390   }
391 
392   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
393                           process->GetAddressByteSize());
394   lldb::offset_t cursor = 0;
395   uint64_t raw_entry = extractor.GetU64_unchecked(&cursor);
396   m_image_index = raw_entry & 0xFFFF;
397   m_list_offset = (int64_t)(raw_entry >> 16);
398   return true;
399 }
400 
401 bool ClassDescriptorV2::relative_list_list_t::Read(Process *process,
402                                                    lldb::addr_t addr) {
403   Log *log = GetLog(LLDBLog::Types);
404   size_t size = sizeof(uint32_t)    // m_entsize
405                 + sizeof(uint32_t); // m_count
406 
407   DataBufferHeap buffer(size, '\0');
408   Status error;
409 
410   // FIXME: Propagate this error up
411   process->ReadMemory(addr, buffer.GetBytes(), size, error);
412   if (error.Fail()) {
413     LLDB_LOG(log, "Failed to read relative_list_list_t at address 0x" PRIx64,
414              addr);
415     return false;
416   }
417 
418   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
419                           process->GetAddressByteSize());
420   lldb::offset_t cursor = 0;
421   m_entsize = extractor.GetU32_unchecked(&cursor);
422   m_count = extractor.GetU32_unchecked(&cursor);
423   m_first_ptr = addr + cursor;
424   return true;
425 }
426 
427 std::optional<ClassDescriptorV2::method_list_t>
428 ClassDescriptorV2::GetMethodList(Process *process,
429                                  lldb::addr_t method_list_ptr) const {
430   Log *log = GetLog(LLDBLog::Types);
431   ClassDescriptorV2::method_list_t method_list;
432   if (!method_list.Read(process, method_list_ptr))
433     return std::nullopt;
434 
435   const size_t method_size = method_t::GetSize(process, method_list.m_is_small);
436   if (method_list.m_entsize != method_size) {
437     LLDB_LOG(log,
438              "method_list_t at address 0x" PRIx64 " has an entsize of " PRIu16
439              " but method size should be " PRIu64,
440              method_list_ptr, method_list.m_entsize, method_size);
441     return std::nullopt;
442   }
443 
444   return method_list;
445 }
446 
447 bool ClassDescriptorV2::ProcessMethodList(
448     std::function<bool(const char *, const char *)> const &instance_method_func,
449     ClassDescriptorV2::method_list_t &method_list) const {
450   lldb_private::Process *process = m_runtime.GetProcess();
451   auto method = std::make_unique<method_t>();
452   lldb::addr_t relative_selector_base_addr =
453       m_runtime.GetRelativeSelectorBaseAddr();
454   for (uint32_t i = 0, e = method_list.m_count; i < e; ++i) {
455     method->Read(process, method_list.m_first_ptr + (i * method_list.m_entsize),
456                  relative_selector_base_addr, method_list.m_is_small,
457                  method_list.m_has_direct_selector);
458     if (instance_method_func(method->m_name.c_str(), method->m_types.c_str()))
459       break;
460   }
461   return true;
462 }
463 
464 // The relevant data structures:
465 //  - relative_list_list_t
466 //    - uint32_t count
467 //    - uint32_t entsize
468 //    - Followed by <count> number of relative_list_entry_t of size <entsize>
469 //
470 //  - relative_list_entry_t
471 //    - uint64_t image_index : 16
472 //    - int64_t list_offset : 48
473 //    - Note: The above 2 fit into 8 bytes always
474 //
475 //    image_index corresponds to an image in the shared cache
476 //    list_offset is used to calculate the address of the method_list_t we want
477 bool ClassDescriptorV2::ProcessRelativeMethodLists(
478     std::function<bool(const char *, const char *)> const &instance_method_func,
479     lldb::addr_t relative_method_list_ptr) const {
480   lldb_private::Process *process = m_runtime.GetProcess();
481   auto relative_method_lists = std::make_unique<relative_list_list_t>();
482 
483   // 1. Process the count and entsize of the relative_list_list_t
484   if (!relative_method_lists->Read(process, relative_method_list_ptr))
485     return false;
486 
487   auto entry = std::make_unique<relative_list_entry_t>();
488   for (uint32_t i = 0; i < relative_method_lists->m_count; i++) {
489     // 2. Extract the image index and the list offset from the
490     // relative_list_entry_t
491     const lldb::addr_t entry_addr = relative_method_lists->m_first_ptr +
492                                     (i * relative_method_lists->m_entsize);
493     if (!entry->Read(process, entry_addr))
494       return false;
495 
496     // 3. Calculate the pointer to the method_list_t from the
497     // relative_list_entry_t
498     const lldb::addr_t method_list_addr = entry_addr + entry->m_list_offset;
499 
500     // 4. Get the method_list_t from the pointer
501     std::optional<method_list_t> method_list =
502         GetMethodList(process, method_list_addr);
503     if (!method_list)
504       return false;
505 
506     // 5. Cache the result so we don't need to reconstruct it later.
507     m_image_to_method_lists[entry->m_image_index].emplace_back(*method_list);
508 
509     // 6. If the relevant image is loaded, add the methods to the Decl
510     if (!m_runtime.IsSharedCacheImageLoaded(entry->m_image_index))
511       continue;
512 
513     if (!ProcessMethodList(instance_method_func, *method_list))
514       return false;
515   }
516 
517   // We need to keep track of the last time we updated so we can re-update the
518   // type information in the future
519   m_last_version_updated = m_runtime.GetSharedCacheImageHeaderVersion();
520 
521   return true;
522 }
523 
524 bool ClassDescriptorV2::Describe(
525     std::function<void(ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
526     std::function<bool(const char *, const char *)> const &instance_method_func,
527     std::function<bool(const char *, const char *)> const &class_method_func,
528     std::function<bool(const char *, const char *, lldb::addr_t,
529                        uint64_t)> const &ivar_func) const {
530   lldb_private::Process *process = m_runtime.GetProcess();
531 
532   std::unique_ptr<objc_class_t> objc_class;
533   std::unique_ptr<class_ro_t> class_ro;
534   std::unique_ptr<class_rw_t> class_rw;
535 
536   if (!Read_objc_class(process, objc_class))
537     return false;
538   if (!Read_class_row(process, *objc_class, class_ro, class_rw))
539     return false;
540 
541   static ConstString NSObject_name("NSObject");
542 
543   if (m_name != NSObject_name && superclass_func)
544     superclass_func(objc_class->m_superclass);
545 
546   if (instance_method_func) {
547     // This is a relative list of lists
548     if (class_ro->m_baseMethods_ptr & 1) {
549       if (!ProcessRelativeMethodLists(instance_method_func,
550                                       class_ro->m_baseMethods_ptr ^ 1))
551         return false;
552     } else {
553       std::optional<method_list_t> base_method_list =
554           GetMethodList(process, class_ro->m_baseMethods_ptr);
555       if (!base_method_list)
556         return false;
557       if (!ProcessMethodList(instance_method_func, *base_method_list))
558         return false;
559     }
560   }
561 
562   if (class_method_func) {
563     AppleObjCRuntime::ClassDescriptorSP metaclass(GetMetaclass());
564 
565     // We don't care about the metaclass's superclass, or its class methods.
566     // Its instance methods are our class methods.
567 
568     if (metaclass) {
569       metaclass->Describe(
570           std::function<void(ObjCLanguageRuntime::ObjCISA)>(nullptr),
571           class_method_func,
572           std::function<bool(const char *, const char *)>(nullptr),
573           std::function<bool(const char *, const char *, lldb::addr_t,
574                              uint64_t)>(nullptr));
575     }
576   }
577 
578   if (ivar_func) {
579     if (class_ro->m_ivars_ptr != 0) {
580       ivar_list_t ivar_list;
581       if (!ivar_list.Read(process, class_ro->m_ivars_ptr))
582         return false;
583 
584       if (ivar_list.m_entsize != ivar_t::GetSize(process))
585         return false;
586 
587       ivar_t ivar;
588 
589       for (uint32_t i = 0, e = ivar_list.m_count; i < e; ++i) {
590         ivar.Read(process, ivar_list.m_first_ptr + (i * ivar_list.m_entsize));
591 
592         if (ivar_func(ivar.m_name.c_str(), ivar.m_type.c_str(),
593                       ivar.m_offset_ptr, ivar.m_size))
594           break;
595       }
596     }
597   }
598 
599   return true;
600 }
601 
602 ConstString ClassDescriptorV2::GetClassName() {
603   if (!m_name) {
604     lldb_private::Process *process = m_runtime.GetProcess();
605 
606     if (process) {
607       std::unique_ptr<objc_class_t> objc_class;
608       std::unique_ptr<class_ro_t> class_ro;
609       std::unique_ptr<class_rw_t> class_rw;
610 
611       if (!Read_objc_class(process, objc_class))
612         return m_name;
613       if (!Read_class_row(process, *objc_class, class_ro, class_rw))
614         return m_name;
615 
616       m_name = ConstString(class_ro->m_name.c_str());
617     }
618   }
619   return m_name;
620 }
621 
622 ObjCLanguageRuntime::ClassDescriptorSP ClassDescriptorV2::GetSuperclass() {
623   lldb_private::Process *process = m_runtime.GetProcess();
624 
625   if (!process)
626     return ObjCLanguageRuntime::ClassDescriptorSP();
627 
628   std::unique_ptr<objc_class_t> objc_class;
629 
630   if (!Read_objc_class(process, objc_class))
631     return ObjCLanguageRuntime::ClassDescriptorSP();
632 
633   return m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(
634       objc_class->m_superclass);
635 }
636 
637 ObjCLanguageRuntime::ClassDescriptorSP ClassDescriptorV2::GetMetaclass() const {
638   lldb_private::Process *process = m_runtime.GetProcess();
639 
640   if (!process)
641     return ObjCLanguageRuntime::ClassDescriptorSP();
642 
643   std::unique_ptr<objc_class_t> objc_class;
644 
645   if (!Read_objc_class(process, objc_class))
646     return ObjCLanguageRuntime::ClassDescriptorSP();
647 
648   lldb::addr_t candidate_isa = m_runtime.GetPointerISA(objc_class->m_isa);
649 
650   return ObjCLanguageRuntime::ClassDescriptorSP(
651       new ClassDescriptorV2(m_runtime, candidate_isa, nullptr));
652 }
653 
654 uint64_t ClassDescriptorV2::GetInstanceSize() {
655   lldb_private::Process *process = m_runtime.GetProcess();
656 
657   if (process) {
658     std::unique_ptr<objc_class_t> objc_class;
659     std::unique_ptr<class_ro_t> class_ro;
660     std::unique_ptr<class_rw_t> class_rw;
661 
662     if (!Read_objc_class(process, objc_class))
663       return 0;
664     if (!Read_class_row(process, *objc_class, class_ro, class_rw))
665       return 0;
666 
667     return class_ro->m_instanceSize;
668   }
669 
670   return 0;
671 }
672 
673 // From the ObjC runtime.
674 static uint8_t IS_SWIFT_STABLE = 1U << 1;
675 
676 LanguageType ClassDescriptorV2::GetImplementationLanguage() const {
677   std::unique_ptr<objc_class_t> objc_class;
678   if (auto *process = m_runtime.GetProcess())
679     if (Read_objc_class(process, objc_class))
680       if (objc_class->m_flags & IS_SWIFT_STABLE)
681         return lldb::eLanguageTypeSwift;
682 
683   return lldb::eLanguageTypeObjC;
684 }
685 
686 ClassDescriptorV2::iVarsStorage::iVarsStorage() : m_ivars(), m_mutex() {}
687 
688 size_t ClassDescriptorV2::iVarsStorage::size() { return m_ivars.size(); }
689 
690 ClassDescriptorV2::iVarDescriptor &ClassDescriptorV2::iVarsStorage::
691 operator[](size_t idx) {
692   return m_ivars[idx];
693 }
694 
695 void ClassDescriptorV2::iVarsStorage::fill(AppleObjCRuntimeV2 &runtime,
696                                            ClassDescriptorV2 &descriptor) {
697   if (m_filled)
698     return;
699   std::lock_guard<std::recursive_mutex> guard(m_mutex);
700   Log *log = GetLog(LLDBLog::Types);
701   LLDB_LOGV(log, "class_name = {0}", descriptor.GetClassName());
702   m_filled = true;
703   ObjCLanguageRuntime::EncodingToTypeSP encoding_to_type_sp(
704       runtime.GetEncodingToType());
705   Process *process(runtime.GetProcess());
706   if (!encoding_to_type_sp)
707     return;
708   descriptor.Describe(nullptr, nullptr, nullptr, [this, process,
709                                                   encoding_to_type_sp,
710                                                   log](const char *name,
711                                                        const char *type,
712                                                        lldb::addr_t offset_ptr,
713                                                        uint64_t size) -> bool {
714     const bool for_expression = false;
715     const bool stop_loop = false;
716     LLDB_LOGV(log, "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = {3}",
717               name, type, offset_ptr, size);
718     CompilerType ivar_type =
719         encoding_to_type_sp->RealizeType(type, for_expression);
720     if (ivar_type) {
721       LLDB_LOGV(log,
722                 "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = "
723                 "{3}, type_size = {4}",
724                 name, type, offset_ptr, size,
725                 ivar_type.GetByteSize(nullptr).value_or(0));
726       Scalar offset_scalar;
727       Status error;
728       const int offset_ptr_size = 4;
729       const bool is_signed = false;
730       size_t read = process->ReadScalarIntegerFromMemory(
731           offset_ptr, offset_ptr_size, is_signed, offset_scalar, error);
732       if (error.Success() && 4 == read) {
733         LLDB_LOGV(log, "offset_ptr = {0:x} --> {1}", offset_ptr,
734                   offset_scalar.SInt());
735         m_ivars.push_back(
736             {ConstString(name), ivar_type, size, offset_scalar.SInt()});
737       } else
738         LLDB_LOGV(log, "offset_ptr = {0:x} --> read fail, read = %{1}",
739                   offset_ptr, read);
740     }
741     return stop_loop;
742   });
743 }
744 
745 void ClassDescriptorV2::GetIVarInformation() {
746   m_ivars_storage.fill(m_runtime, *this);
747 }
748