LLDB mainline
NSSet.cpp
Go to the documentation of this file.
1//===-- NSSet.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 "NSSet.h"
10#include "CFBasicHash.h"
11
18#include "lldb/Target/Target.h"
20#include "lldb/Utility/Endian.h"
21#include "lldb/Utility/Status.h"
22#include "lldb/Utility/Stream.h"
23
24using namespace lldb;
25using namespace lldb_private;
26using namespace lldb_private::formatters;
27
28std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
30 static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
31 return g_map;
32}
33
34std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> &
36 static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>
37 g_map;
38 return g_map;
39}
40
41namespace lldb_private {
42namespace formatters {
44public:
46
47 ~NSSetISyntheticFrontEnd() override;
48
49 size_t CalculateNumChildren() override;
50
51 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
52
53 bool Update() override;
54
55 bool MightHaveChildren() override;
56
57 size_t GetIndexOfChildWithName(ConstString name) override;
58
59private:
61 uint32_t _used : 26;
62 uint32_t _szidx : 6;
63 };
64
66 uint64_t _used : 58;
67 uint32_t _szidx : 6;
68 };
69
73 };
74
76 uint8_t m_ptr_size = 8;
77 DataDescriptor_32 *m_data_32 = nullptr;
78 DataDescriptor_64 *m_data_64 = nullptr;
80 std::vector<SetItemDescriptor> m_children;
81};
82
84public:
86
87 size_t CalculateNumChildren() override;
88
89 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
90
91 bool Update() override;
92
93 bool MightHaveChildren() override;
94
95 size_t GetIndexOfChildWithName(ConstString name) override;
96
97private:
101 };
102
104 uint8_t m_ptr_size = 8;
106
108
110 std::vector<SetItemDescriptor> m_children;
111};
112
113template <typename D32, typename D64>
115public:
117
119
120 size_t CalculateNumChildren() override;
121
122 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
123
124 bool Update() override;
125
126 bool MightHaveChildren() override;
127
128 size_t GetIndexOfChildWithName(ConstString name) override;
129
130private:
131
135 };
136
138 uint8_t m_ptr_size = 8;
141 std::vector<SetItemDescriptor> m_children;
142};
143
144namespace Foundation1300 {
146 uint32_t _used : 26;
147 uint32_t _size;
148 uint32_t _mutations;
149 uint32_t _objs_addr;
150 };
151
153 uint64_t _used : 58;
154 uint64_t _size;
155 uint64_t _mutations;
156 uint64_t _objs_addr;
157 };
158
161}
162
163namespace Foundation1428 {
164 struct DataDescriptor_32 {
165 uint32_t _used : 26;
166 uint32_t _size;
167 uint32_t _objs_addr;
168 uint32_t _mutations;
169 };
170
171 struct DataDescriptor_64 {
172 uint64_t _used : 58;
173 uint64_t _size;
174 uint64_t _objs_addr;
175 uint64_t _mutations;
176 };
177
180}
181
182namespace Foundation1437 {
183 struct DataDescriptor_32 {
184 uint32_t _cow;
185 // __table storage
186 uint32_t _objs_addr;
187 uint32_t _muts;
188 uint32_t _used : 26;
189 uint32_t _szidx : 6;
190 };
191
192 struct DataDescriptor_64 {
193 uint64_t _cow;
194 // __Table storage
195 uint64_t _objs_addr;
196 uint32_t _muts;
197 uint32_t _used : 26;
198 uint32_t _szidx : 6;
199 };
200
203
204 template <typename DD>
205 uint64_t
207 Status &error) {
208 const lldb::addr_t start_of_descriptor =
209 valobj_addr + process.GetAddressByteSize();
210 DD descriptor = DD();
211 process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),
212 error);
213 if (error.Fail()) {
214 return 0;
215 }
216 return descriptor._used;
217 }
218
219 uint64_t
221 Status &error) {
222 if (process.GetAddressByteSize() == 4) {
223 return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr, error);
224 } else {
225 return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr, error);
226 }
227 }
228}
229
231public:
233
235
236 size_t CalculateNumChildren() override;
237
239
240 bool Update() override;
241
242 bool MightHaveChildren() override;
243
245};
246} // namespace formatters
247} // namespace lldb_private
248
249template <bool cf_style>
251 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
252 static constexpr llvm::StringLiteral g_TypeHint("NSSet");
253
254 ProcessSP process_sp = valobj.GetProcessSP();
255 if (!process_sp)
256 return false;
257
258 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
259
260 if (!runtime)
261 return false;
262
264 runtime->GetClassDescriptor(valobj));
265
266 if (!descriptor || !descriptor->IsValid())
267 return false;
268
269 uint32_t ptr_size = process_sp->GetAddressByteSize();
270 bool is_64bit = (ptr_size == 8);
271
272 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
273
274 if (!valobj_addr)
275 return false;
276
277 uint64_t value = 0;
278
279 ConstString class_name(descriptor->GetClassName());
280
281 static const ConstString g_SetI("__NSSetI");
282 static const ConstString g_OrderedSetI("__NSOrderedSetI");
283 static const ConstString g_SetM("__NSSetM");
284 static const ConstString g_SetCF("__NSCFSet");
285 static const ConstString g_SetCFRef("CFSetRef");
286
287 if (class_name.IsEmpty())
288 return false;
289
290 if (class_name == g_SetI || class_name == g_OrderedSetI) {
292 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
293 ptr_size, 0, error);
294 if (error.Fail())
295 return false;
296 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
297 } else if (class_name == g_SetM) {
298 AppleObjCRuntime *apple_runtime =
299 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
301 if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
302 value = Foundation1437::__NSSetMSize(*process_sp, valobj_addr, error);
303 } else {
304 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
305 ptr_size, 0, error);
306 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
307 }
308 if (error.Fail())
309 return false;
310 } else if (class_name == g_SetCF || class_name == g_SetCFRef) {
311 ExecutionContext exe_ctx(process_sp);
312 CFBasicHash cfbh;
313 if (!cfbh.Update(valobj_addr, exe_ctx))
314 return false;
315 value = cfbh.GetCount();
316 } else {
318 auto iter = map.find(class_name), end = map.end();
319 if (iter != end)
320 return iter->second(valobj, stream, options);
321 else
322 return false;
323 }
324
325 llvm::StringRef prefix, suffix;
326 if (Language *language = Language::FindPlugin(options.GetLanguage()))
327 std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
328
329 stream << prefix;
330 stream.Printf("%" PRIu64 " %s%s", value, "element", value == 1 ? "" : "s");
331 stream << suffix;
332 return true;
333}
334
337 CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
338 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
339 if (!process_sp)
340 return nullptr;
341 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
342 if (!runtime)
343 return nullptr;
344
345 CompilerType valobj_type(valobj_sp->GetCompilerType());
346 Flags flags(valobj_type.GetTypeInfo());
347
348 if (flags.IsClear(eTypeIsPointer)) {
350 valobj_sp = valobj_sp->AddressOf(error);
351 if (error.Fail() || !valobj_sp)
352 return nullptr;
353 }
354
356 runtime->GetClassDescriptor(*valobj_sp));
357
358 if (!descriptor || !descriptor->IsValid())
359 return nullptr;
360
361 ConstString class_name = descriptor->GetClassName();
362
363 static const ConstString g_SetI("__NSSetI");
364 static const ConstString g_OrderedSetI("__NSOrderedSetI");
365 static const ConstString g_SetM("__NSSetM");
366 static const ConstString g_SetCF("__NSCFSet");
367 static const ConstString g_SetCFRef("CFSetRef");
368
369 if (class_name.IsEmpty())
370 return nullptr;
371
372 if (class_name == g_SetI || class_name == g_OrderedSetI) {
373 return (new NSSetISyntheticFrontEnd(valobj_sp));
374 } else if (class_name == g_SetM) {
375 AppleObjCRuntime *apple_runtime =
376 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
377 if (apple_runtime) {
378 if (apple_runtime->GetFoundationVersion() >= 1437)
379 return (new Foundation1437::NSSetMSyntheticFrontEnd(valobj_sp));
380 else if (apple_runtime->GetFoundationVersion() >= 1428)
381 return (new Foundation1428::NSSetMSyntheticFrontEnd(valobj_sp));
382 else
383 return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
384 } else {
385 return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
386 }
387 } else if (class_name == g_SetCF || class_name == g_SetCFRef) {
388 return (new NSCFSetSyntheticFrontEnd(valobj_sp));
389 } else {
391 auto iter = map.find(class_name), end = map.end();
392 if (iter != end)
393 return iter->second(synth, valobj_sp);
394 return nullptr;
395 }
396}
397
399 lldb::ValueObjectSP valobj_sp)
400 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref() {
401 if (valobj_sp)
402 Update();
403}
404
406 delete m_data_32;
407 m_data_32 = nullptr;
408 delete m_data_64;
409 m_data_64 = nullptr;
410}
411
412size_t
414 ConstString name) {
415 const char *item_name = name.GetCString();
416 uint32_t idx = ExtractIndexFromString(item_name);
417 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
418 return UINT32_MAX;
419 return idx;
420}
421
422size_t
424 if (!m_data_32 && !m_data_64)
425 return 0;
426 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
427}
428
430 m_children.clear();
431 delete m_data_32;
432 m_data_32 = nullptr;
433 delete m_data_64;
434 m_data_64 = nullptr;
435 m_ptr_size = 0;
436 ValueObjectSP valobj_sp = m_backend.GetSP();
437 if (!valobj_sp)
438 return false;
439 if (!valobj_sp)
440 return false;
441 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
442 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
443 if (!process_sp)
444 return false;
445 m_ptr_size = process_sp->GetAddressByteSize();
446 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
448 if (m_ptr_size == 4) {
449 m_data_32 = new DataDescriptor_32();
450 process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
451 error);
452 } else {
453 m_data_64 = new DataDescriptor_64();
454 process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
455 error);
456 }
457 if (error.Fail())
458 return false;
459 m_data_ptr = data_location + m_ptr_size;
460 return true;
461}
462
464 return true;
465}
466
469 uint32_t num_children = CalculateNumChildren();
470
471 if (idx >= num_children)
472 return lldb::ValueObjectSP();
473
474 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
475 if (!process_sp)
476 return lldb::ValueObjectSP();
477
478 if (m_children.empty()) {
479 // do the scan phase
480 lldb::addr_t obj_at_idx = 0;
481
482 uint32_t tries = 0;
483 uint32_t test_idx = 0;
484
485 while (tries < num_children) {
486 obj_at_idx = m_data_ptr + (test_idx * m_ptr_size);
487 if (!process_sp)
488 return lldb::ValueObjectSP();
490 obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
491 if (error.Fail())
492 return lldb::ValueObjectSP();
493
494 test_idx++;
495
496 if (!obj_at_idx)
497 continue;
498 tries++;
499
500 SetItemDescriptor descriptor = {obj_at_idx, lldb::ValueObjectSP()};
501
502 m_children.push_back(descriptor);
503 }
504 }
505
506 if (idx >= m_children.size()) // should never happen
507 return lldb::ValueObjectSP();
508
509 SetItemDescriptor &set_item = m_children[idx];
510 if (!set_item.valobj_sp) {
511 auto ptr_size = process_sp->GetAddressByteSize();
512 DataBufferHeap buffer(ptr_size, 0);
513 switch (ptr_size) {
514 case 0: // architecture has no clue - fail
515 return lldb::ValueObjectSP();
516 case 4:
517 *reinterpret_cast<uint32_t *>(buffer.GetBytes()) =
518 static_cast<uint32_t>(set_item.item_ptr);
519 break;
520 case 8:
521 *reinterpret_cast<uint64_t *>(buffer.GetBytes()) =
522 static_cast<uint64_t>(set_item.item_ptr);
523 break;
524 default:
525 lldbassert(false && "pointer size is not 4 nor 8");
526 }
527 StreamString idx_name;
528 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
529
530 DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
531 process_sp->GetByteOrder(),
532 process_sp->GetAddressByteSize());
533
534 set_item.valobj_sp = CreateValueObjectFromData(
535 idx_name.GetString(), data, m_exe_ctx_ref,
536 m_backend.GetCompilerType().GetBasicTypeFromAST(
538 }
539 return set_item.valobj_sp;
540}
541
543 lldb::ValueObjectSP valobj_sp)
544 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_hashtable(),
545 m_pair_type() {}
546
547size_t
549 ConstString name) {
550 const char *item_name = name.GetCString();
551 const uint32_t idx = ExtractIndexFromString(item_name);
552 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
553 return UINT32_MAX;
554 return idx;
555}
556
557size_t
559 if (!m_hashtable.IsValid())
560 return 0;
561 return m_hashtable.GetCount();
562}
563
565 m_children.clear();
566 ValueObjectSP valobj_sp = m_backend.GetSP();
567 m_ptr_size = 0;
568 if (!valobj_sp)
569 return false;
570 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
571
572 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
573 if (!process_sp)
574 return false;
575 m_ptr_size = process_sp->GetAddressByteSize();
576 m_order = process_sp->GetByteOrder();
577 return m_hashtable.Update(valobj_sp->GetValueAsUnsigned(0), m_exe_ctx_ref);
578}
579
581 return true;
582}
583
586 size_t idx) {
587 lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();
588
589 const uint32_t num_children = CalculateNumChildren();
590
591 if (idx >= num_children)
592 return lldb::ValueObjectSP();
593
594 if (m_children.empty()) {
595 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
596 if (!process_sp)
597 return lldb::ValueObjectSP();
598
600 lldb::addr_t val_at_idx = 0;
601
602 uint32_t tries = 0;
603 uint32_t test_idx = 0;
604
605 // Iterate over inferior memory, reading value pointers by shifting the
606 // cursor by test_index * m_ptr_size. Returns an empty ValueObject if a read
607 // fails, otherwise, continue until the number of tries matches the number
608 // of childen.
609 while (tries < num_children) {
610 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
611
612 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
613 if (error.Fail())
614 return lldb::ValueObjectSP();
615
616 test_idx++;
617
618 if (!val_at_idx)
619 continue;
620 tries++;
621
622 SetItemDescriptor descriptor = {val_at_idx, lldb::ValueObjectSP()};
623
624 m_children.push_back(descriptor);
625 }
626 }
627
628 if (idx >= m_children.size()) // should never happen
629 return lldb::ValueObjectSP();
630
631 SetItemDescriptor &set_item = m_children[idx];
632 if (!set_item.valobj_sp) {
633
634 WritableDataBufferSP buffer_sp(new DataBufferHeap(m_ptr_size, 0));
635
636 switch (m_ptr_size) {
637 case 0: // architecture has no clue - fail
638 return lldb::ValueObjectSP();
639 case 4:
640 *reinterpret_cast<uint32_t *>(buffer_sp->GetBytes()) =
641 static_cast<uint32_t>(set_item.item_ptr);
642 break;
643 case 8:
644 *reinterpret_cast<uint64_t *>(buffer_sp->GetBytes()) =
645 static_cast<uint64_t>(set_item.item_ptr);
646 break;
647 default:
648 lldbassert(false && "pointer size is not 4 nor 8");
649 }
650 StreamString idx_name;
651 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
652
653 DataExtractor data(buffer_sp, m_order, m_ptr_size);
654
655 set_item.valobj_sp = CreateValueObjectFromData(
656 idx_name.GetString(), data, m_exe_ctx_ref,
657 m_backend.GetCompilerType().GetBasicTypeFromAST(
659 }
660
661 return set_item.valobj_sp;
662}
663
664template <typename D32, typename D64>
667 : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
668 m_data_32(nullptr), m_data_64(nullptr) {
669 if (valobj_sp)
670 Update();
671}
672
673template <typename D32, typename D64>
674lldb_private::formatters::
675 GenericNSSetMSyntheticFrontEnd<D32, D64>::~GenericNSSetMSyntheticFrontEnd<D32, D64>() {
676 delete m_data_32;
677 m_data_32 = nullptr;
678 delete m_data_64;
679 m_data_64 = nullptr;
680}
681
682template <typename D32, typename D64>
683size_t
686 ConstString name) {
687 const char *item_name = name.GetCString();
688 uint32_t idx = ExtractIndexFromString(item_name);
689 if (idx < UINT32_MAX && idx >= CalculateNumChildren())
690 return UINT32_MAX;
691 return idx;
692}
693
694template <typename D32, typename D64>
695size_t
698 if (!m_data_32 && !m_data_64)
699 return 0;
700 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
701}
702
703template <typename D32, typename D64>
704bool
707 m_children.clear();
708 ValueObjectSP valobj_sp = m_backend.GetSP();
709 m_ptr_size = 0;
710 delete m_data_32;
711 m_data_32 = nullptr;
712 delete m_data_64;
713 m_data_64 = nullptr;
714 if (!valobj_sp)
715 return false;
716 if (!valobj_sp)
717 return false;
718 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
719 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
720 if (!process_sp)
721 return false;
722 m_ptr_size = process_sp->GetAddressByteSize();
723 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
725 if (m_ptr_size == 4) {
726 m_data_32 = new D32();
727 process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
728 error);
729 } else {
730 m_data_64 = new D64();
731 process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
732 error);
733 }
734 return error.Success();
735}
736
737template <typename D32, typename D64>
738bool
741 return true;
742}
743
744template <typename D32, typename D64>
748 lldb::addr_t m_objs_addr =
749 (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
750
751 uint32_t num_children = CalculateNumChildren();
752
753 if (idx >= num_children)
754 return lldb::ValueObjectSP();
755
756 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
757 if (!process_sp)
758 return lldb::ValueObjectSP();
759
760 if (m_children.empty()) {
761 // do the scan phase
762 lldb::addr_t obj_at_idx = 0;
763
764 uint32_t tries = 0;
765 uint32_t test_idx = 0;
766
767 while (tries < num_children) {
768 obj_at_idx = m_objs_addr + (test_idx * m_ptr_size);
769 if (!process_sp)
770 return lldb::ValueObjectSP();
772 obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
773 if (error.Fail())
774 return lldb::ValueObjectSP();
775
776 test_idx++;
777
778 if (!obj_at_idx)
779 continue;
780 tries++;
781
782 SetItemDescriptor descriptor = {obj_at_idx, lldb::ValueObjectSP()};
783
784 m_children.push_back(descriptor);
785 }
786 }
787
788 if (idx >= m_children.size()) // should never happen
789 return lldb::ValueObjectSP();
790
791 SetItemDescriptor &set_item = m_children[idx];
792 if (!set_item.valobj_sp) {
793 auto ptr_size = process_sp->GetAddressByteSize();
794 DataBufferHeap buffer(ptr_size, 0);
795 switch (ptr_size) {
796 case 0: // architecture has no clue?? - fail
797 return lldb::ValueObjectSP();
798 case 4:
799 *((uint32_t *)buffer.GetBytes()) = (uint32_t)set_item.item_ptr;
800 break;
801 case 8:
802 *((uint64_t *)buffer.GetBytes()) = (uint64_t)set_item.item_ptr;
803 break;
804 default:
805 assert(false && "pointer size is not 4 nor 8 - get out of here ASAP");
806 }
807 StreamString idx_name;
808 idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
809
810 DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
811 process_sp->GetByteOrder(),
812 process_sp->GetAddressByteSize());
813
814 set_item.valobj_sp = CreateValueObjectFromData(
815 idx_name.GetString(), data, m_exe_ctx_ref,
816 m_backend.GetCompilerType().GetBasicTypeFromAST(
818 }
819 return set_item.valobj_sp;
820}
821
822template bool lldb_private::formatters::NSSetSummaryProvider<true>(
823 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
824
825template bool lldb_private::formatters::NSSetSummaryProvider<false>(
826 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
static llvm::raw_ostream & error(Stream &strm)
#define lldbassert(x)
Definition: LLDBAssert.h:15
static std::optional< size_t > CalculateNumChildren(CompilerType container_elem_type, uint64_t num_elements, CompilerType element_type)
Calculates the number of elements stored in a container (with element type 'container_elem_type') as ...
Definition: VectorType.cpp:197
bool Update(lldb::addr_t addr, ExecutionContextRef exe_ctx_rf)
Definition: CFBasicHash.cpp:20
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
A uniqued constant string class.
Definition: ConstString.h:40
bool IsEmpty() const
Test for empty string.
Definition: ConstString.h:293
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:205
A subclass of DataBuffer that stores a data buffer on the heap.
lldb::offset_t GetByteSize() const override
Get the number of bytes in the data buffer.
An data extractor class.
Definition: DataExtractor.h:48
Execution context objects refer to objects in the execution of the program that is being debugged.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A class to manage flags.
Definition: Flags.h:22
bool IsClear(ValueType bit) const
Test a single flag bit to see if it is clear (zero).
Definition: Flags.h:111
static Language * FindPlugin(lldb::LanguageType language)
Definition: Language.cpp:53
std::shared_ptr< ClassDescriptor > ClassDescriptorSP
static ObjCLanguageRuntime * Get(Process &process)
virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value)
A plug-in interface definition class for debugging a process.
Definition: Process.h:339
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:1930
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3398
An error handling class.
Definition: Status.h:44
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb::LanguageType GetLanguage() const
Definition: TypeSummary.cpp:31
lldb::ProcessSP GetProcessSP() const
Definition: ValueObject.h:338
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
uint8_t * GetBytes()
Get a pointer to the data.
Definition: DataBuffer.h:108
size_t GetIndexOfChildWithName(ConstString name) override
Definition: NSSet.cpp:685
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override
Definition: NSSet.cpp:747
std::vector< SetItemDescriptor > m_children
Definition: NSSet.cpp:141
NSCFSetSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
Definition: NSSet.cpp:542
size_t GetIndexOfChildWithName(ConstString name) override
Definition: NSSet.cpp:548
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override
Definition: NSSet.cpp:585
std::vector< SetItemDescriptor > m_children
Definition: NSSet.cpp:110
NSSetCodeRunningSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
size_t GetIndexOfChildWithName(ConstString name) override
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override
Definition: NSSet.cpp:468
size_t GetIndexOfChildWithName(ConstString name) override
Definition: NSSet.cpp:413
NSSetISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
Definition: NSSet.cpp:398
std::vector< SetItemDescriptor > m_children
Definition: NSSet.cpp:80
static std::map< ConstString, CXXFunctionSummaryFormat::Callback > & GetAdditionalSummaries()
Definition: NSSet.cpp:29
static std::map< ConstString, CXXSyntheticChildren::CreateFrontEndCallback > & GetAdditionalSynthetics()
Definition: NSSet.cpp:35
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
uint64_t __NSSetMSize(lldb_private::Process &process, lldb::addr_t valobj_addr, Status &error)
Definition: NSSet.cpp:220
uint64_t __NSSetMSize_Impl(lldb_private::Process &process, lldb::addr_t valobj_addr, Status &error)
Definition: NSSet.cpp:206
size_t ExtractIndexFromString(const char *item_name)
bool NSSetSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options)
Definition: NSSet.cpp:250
SyntheticChildrenFrontEnd * NSSetSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP)
Definition: NSSet.cpp:336
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
@ eBasicTypeObjCID
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:467
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:377
ByteOrder
Byte ordering definitions.
@ eByteOrderInvalid
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:325
uint64_t addr_t
Definition: lldb-types.h:79