28std::map<ConstString, CXXFunctionSummaryFormat::Callback> &
30 static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
34std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> &
36 static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback>
53 bool Update()
override;
55 bool MightHaveChildren()
override;
57 size_t GetIndexOfChildWithName(
ConstString name)
override;
76 uint8_t m_ptr_size = 8;
91 bool Update()
override;
93 bool MightHaveChildren()
override;
95 size_t GetIndexOfChildWithName(
ConstString name)
override;
104 uint8_t m_ptr_size = 8;
113template <
typename D32,
typename D64>
124 bool Update()
override;
126 bool MightHaveChildren()
override;
128 size_t GetIndexOfChildWithName(
ConstString name)
override;
138 uint8_t m_ptr_size = 8;
144namespace Foundation1300 {
163namespace Foundation1428 {
164 struct DataDescriptor_32 {
171 struct DataDescriptor_64 {
182namespace Foundation1437 {
183 struct DataDescriptor_32 {
192 struct DataDescriptor_64 {
204 template <
typename DD>
210 DD descriptor = DD();
211 process.
ReadMemory(start_of_descriptor, &descriptor,
sizeof(descriptor),
216 return descriptor._used;
223 return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr,
error);
225 return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr,
error);
249template <
bool cf_style>
252 static constexpr llvm::StringLiteral g_TypeHint(
"NSSet");
266 if (!descriptor || !descriptor->IsValid())
269 uint32_t ptr_size = process_sp->GetAddressByteSize();
270 bool is_64bit = (ptr_size == 8);
279 ConstString class_name(descriptor->GetClassName());
282 static const ConstString g_OrderedSetI(
"__NSOrderedSetI");
290 if (class_name == g_SetI || class_name == g_OrderedSetI) {
292 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
296 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
297 }
else if (class_name == g_SetM) {
299 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
304 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
306 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
310 }
else if (class_name == g_SetCF || class_name == g_SetCFRef) {
313 if (!cfbh.
Update(valobj_addr, exe_ctx))
318 auto iter = map.find(class_name), end = map.end();
320 return iter->second(valobj, stream, options);
325 llvm::StringRef prefix, suffix;
327 std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
330 stream.
Printf(
"%" PRIu64
" %s%s", value,
"element", value == 1 ?
"" :
"s");
348 if (flags.
IsClear(eTypeIsPointer)) {
350 valobj_sp = valobj_sp->AddressOf(
error);
351 if (
error.Fail() || !valobj_sp)
358 if (!descriptor || !descriptor->IsValid())
361 ConstString class_name = descriptor->GetClassName();
364 static const ConstString g_OrderedSetI(
"__NSOrderedSetI");
372 if (class_name == g_SetI || class_name == g_OrderedSetI) {
374 }
else if (class_name == g_SetM) {
376 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
387 }
else if (class_name == g_SetCF || class_name == g_SetCFRef) {
391 auto iter = map.find(class_name), end = map.end();
393 return iter->second(synth, valobj_sp);
424 if (!m_data_32 && !m_data_64)
426 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
441 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
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) {
459 m_data_ptr = data_location + m_ptr_size;
471 if (idx >= num_children)
474 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
478 if (m_children.empty()) {
483 uint32_t test_idx = 0;
485 while (tries < num_children) {
486 obj_at_idx = m_data_ptr + (test_idx * m_ptr_size);
490 obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx,
error);
502 m_children.push_back(descriptor);
506 if (idx >= m_children.size())
511 auto ptr_size = process_sp->GetAddressByteSize();
517 *
reinterpret_cast<uint32_t *
>(buffer.
GetBytes()) =
518 static_cast<uint32_t
>(set_item.
item_ptr);
521 *
reinterpret_cast<uint64_t *
>(buffer.
GetBytes()) =
522 static_cast<uint64_t
>(set_item.
item_ptr);
525 lldbassert(
false &&
"pointer size is not 4 nor 8");
528 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
531 process_sp->GetByteOrder(),
532 process_sp->GetAddressByteSize());
534 set_item.
valobj_sp = CreateValueObjectFromData(
535 idx_name.
GetString(), data, m_exe_ctx_ref,
536 m_backend.GetCompilerType().GetBasicTypeFromAST(
559 if (!m_hashtable.IsValid())
561 return m_hashtable.GetCount();
570 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
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);
587 lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();
591 if (idx >= num_children)
594 if (m_children.empty()) {
595 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
603 uint32_t test_idx = 0;
609 while (tries < num_children) {
610 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
612 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
624 m_children.push_back(descriptor);
628 if (idx >= m_children.size())
636 switch (m_ptr_size) {
640 *
reinterpret_cast<uint32_t *
>(buffer_sp->GetBytes()) =
641 static_cast<uint32_t
>(set_item.
item_ptr);
644 *
reinterpret_cast<uint64_t *
>(buffer_sp->GetBytes()) =
645 static_cast<uint64_t
>(set_item.
item_ptr);
648 lldbassert(
false &&
"pointer size is not 4 nor 8");
651 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
655 set_item.
valobj_sp = CreateValueObjectFromData(
656 idx_name.
GetString(), data, m_exe_ctx_ref,
657 m_backend.GetCompilerType().GetBasicTypeFromAST(
664template <
typename D32,
typename D64>
668 m_data_32(nullptr), m_data_64(nullptr) {
673template <
typename D32,
typename D64>
674lldb_private::formatters::
675 GenericNSSetMSyntheticFrontEnd<D32, D64>::~GenericNSSetMSyntheticFrontEnd<D32, D64>() {
682template <
typename D32,
typename D64>
694template <
typename D32,
typename D64>
698 if (!m_data_32 && !m_data_64)
700 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
703template <
typename D32,
typename D64>
718 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
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),
730 m_data_64 =
new D64();
731 process_sp->ReadMemory(data_location, m_data_64,
sizeof(D64),
734 return error.Success();
737template <
typename D32,
typename D64>
744template <
typename D32,
typename D64>
749 (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
753 if (idx >= num_children)
756 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
760 if (m_children.empty()) {
765 uint32_t test_idx = 0;
767 while (tries < num_children) {
768 obj_at_idx = m_objs_addr + (test_idx * m_ptr_size);
772 obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx,
error);
784 m_children.push_back(descriptor);
788 if (idx >= m_children.size())
793 auto ptr_size = process_sp->GetAddressByteSize();
805 assert(
false &&
"pointer size is not 4 nor 8 - get out of here ASAP");
808 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
811 process_sp->GetByteOrder(),
812 process_sp->GetAddressByteSize());
814 set_item.
valobj_sp = CreateValueObjectFromData(
815 idx_name.
GetString(), data, m_exe_ctx_ref,
816 m_backend.GetCompilerType().GetBasicTypeFromAST(
822template bool lldb_private::formatters::NSSetSummaryProvider<true>(
825template bool lldb_private::formatters::NSSetSummaryProvider<false>(
static llvm::raw_ostream & error(Stream &strm)
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 ...
uint32_t GetFoundationVersion()
bool Update(lldb::addr_t addr, ExecutionContextRef exe_ctx_rf)
Generic representation of a type in a programming language.
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
A uniqued constant string class.
bool IsEmpty() const
Test for empty string.
const char * GetCString() const
Get the string value as a C string.
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.
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.
bool IsClear(ValueType bit) const
Test a single flag bit to see if it is clear (zero).
static Language * FindPlugin(lldb::LanguageType language)
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.
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
uint32_t GetAddressByteSize() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
lldb::LanguageType GetLanguage() const
lldb::ProcessSP GetProcessSP() const
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
uint8_t * GetBytes()
Get a pointer to the data.
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::Process > ProcessSP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP