11#include "clang/AST/DeclCXX.h"
40 return class_name.
GetStringRef().startswith(m_prefix.GetStringRef());
48 return (class_name == m_name);
69 TypeSystemClangSP scratch_ts_sp =
73 ConstString g_lldb_autogen_nspair(
"__lldb_autogen_nspair");
75 compiler_type = scratch_ts_sp->GetTypeForIdentifier<clang::CXXRecordDecl>(
76 g_lldb_autogen_nspair);
79 compiler_type = scratch_ts_sp->CreateRecordType(
81 g_lldb_autogen_nspair.
GetCString(), clang::TTK_Struct,
100namespace formatters {
109 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
111 bool Update()
override;
113 bool MightHaveChildren()
override;
115 size_t GetIndexOfChildWithName(
ConstString name)
override;
135 uint8_t m_ptr_size = 8;
150 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
152 bool Update()
override;
154 bool MightHaveChildren()
override;
156 size_t GetIndexOfChildWithName(
ConstString name)
override;
161 uint8_t m_ptr_size = 8;
163 unsigned int m_size = 0;
182 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
184 bool Update()
override;
186 bool MightHaveChildren()
override;
188 size_t GetIndexOfChildWithName(
ConstString name)
override;
198 uint8_t m_ptr_size = 8;
215 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
217 bool Update()
override;
219 bool MightHaveChildren()
override;
221 size_t GetIndexOfChildWithName(
ConstString name)
override;
227template <
typename D32,
typename D64>
236 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
238 bool Update()
override;
240 bool MightHaveChildren()
override;
242 size_t GetIndexOfChildWithName(
ConstString name)
override;
252 uint8_t m_ptr_size = 8;
260namespace Foundation1100 {
269 lldb::ValueObjectSP GetChildAtIndex(
size_t idx)
override;
271 bool Update()
override;
273 bool MightHaveChildren()
override;
275 size_t GetIndexOfChildWithName(
ConstString name)
override;
303 uint8_t m_ptr_size = 8;
312namespace Foundation1428 {
314 struct DataDescriptor_32 {
319 uint64_t GetSize() {
return _size; }
322 struct DataDescriptor_64 {
327 uint64_t GetSize() {
return _size; }
335namespace Foundation1437 {
337 0, 3, 7, 13, 23, 41, 71, 127, 191, 251, 383, 631, 1087, 1723,
338 2803, 4523, 7351, 11959, 19447, 31231, 50683, 81919, 132607,
339 214519, 346607, 561109, 907759, 1468927, 2376191, 3845119,
340 6221311, 10066421, 16287743, 26354171, 42641881, 68996069,
341 111638519, 180634607, 292272623, 472907251
348 struct DataDescriptor_32 {
356 return (
_szidx) >= NSDictionaryNumSizeBuckets ?
357 0 : NSDictionaryCapacities[
_szidx];
361 struct DataDescriptor_64 {
378 template <
typename DD>
384 DD descriptor = DD();
385 process.
ReadMemory(start_of_descriptor, &descriptor,
sizeof(descriptor),
390 return descriptor._used;
397 return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr,
400 return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,
409template <
bool name_entries>
412 static constexpr llvm::StringLiteral g_TypeHint(
"NSDictionary");
425 if (!descriptor || !descriptor->IsValid())
428 uint32_t ptr_size = process_sp->GetAddressByteSize();
429 bool is_64bit = (ptr_size == 8);
438 ConstString class_name(descriptor->GetClassName());
440 static const ConstString g_DictionaryI(
"__NSDictionaryI");
441 static const ConstString g_DictionaryM(
"__NSDictionaryM");
442 static const ConstString g_DictionaryMLegacy(
"__NSDictionaryM_Legacy");
443 static const ConstString g_DictionaryMImmutable(
"__NSDictionaryM_Immutable");
444 static const ConstString g_DictionaryMFrozen(
"__NSFrozenDictionaryM");
445 static const ConstString g_Dictionary1(
"__NSSingleEntryDictionaryI");
446 static const ConstString g_Dictionary0(
"__NSDictionary0");
447 static const ConstString g_DictionaryCF(
"__CFDictionary");
448 static const ConstString g_DictionaryNSCF(
"__NSCFDictionary");
449 static const ConstString g_DictionaryCFRef(
"CFDictionaryRef");
450 static const ConstString g_ConstantDictionary(
"NSConstantDictionary");
455 if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {
457 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
462 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
463 }
else if (class_name == g_ConstantDictionary) {
465 value = process_sp->ReadUnsignedIntegerFromMemory(
466 valobj_addr + 2 * ptr_size, ptr_size, 0,
error);
469 }
else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy ||
470 class_name == g_DictionaryMFrozen) {
472 llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
478 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
480 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
484 }
else if (class_name == g_Dictionary1) {
486 }
else if (class_name == g_Dictionary0) {
488 }
else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||
489 class_name == g_DictionaryCFRef) {
492 if (!cfbh.
Update(valobj_addr, exe_ctx))
497 for (
auto &candidate : map) {
498 if (candidate.first && candidate.first->Match(class_name))
499 return candidate.second(valobj, stream, options);
504 llvm::StringRef prefix, suffix;
506 std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
509 stream.
Printf(
"%" PRIu64
" %s%s", value,
"key/value pair",
510 value == 1 ?
"" :
"s");
518 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
529 if (flags.
IsClear(eTypeIsPointer)) {
531 valobj_sp = valobj_sp->AddressOf(
error);
532 if (
error.Fail() || !valobj_sp)
539 if (!descriptor || !descriptor->IsValid())
542 ConstString class_name(descriptor->GetClassName());
544 static const ConstString g_DictionaryI(
"__NSDictionaryI");
545 static const ConstString g_DictionaryM(
"__NSDictionaryM");
546 static const ConstString g_Dictionary1(
"__NSSingleEntryDictionaryI");
547 static const ConstString g_DictionaryImmutable(
"__NSDictionaryM_Immutable");
548 static const ConstString g_DictionaryMFrozen(
"__NSFrozenDictionaryM");
549 static const ConstString g_DictionaryMLegacy(
"__NSDictionaryM_Legacy");
550 static const ConstString g_Dictionary0(
"__NSDictionary0");
551 static const ConstString g_DictionaryCF(
"__CFDictionary");
552 static const ConstString g_DictionaryNSCF(
"__NSCFDictionary");
553 static const ConstString g_DictionaryCFRef(
"CFDictionaryRef");
554 static const ConstString g_ConstantDictionary(
"NSConstantDictionary");
559 if (class_name == g_DictionaryI) {
561 }
else if (class_name == g_ConstantDictionary) {
563 }
else if (class_name == g_DictionaryM || class_name == g_DictionaryMFrozen) {
571 }
else if (class_name == g_DictionaryMLegacy) {
573 }
else if (class_name == g_Dictionary1) {
575 }
else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||
576 class_name == g_DictionaryCFRef) {
580 for (
auto &candidate : map) {
581 if (candidate.first && candidate.first->Match((class_name)))
582 return candidate.second(synth, valobj_sp);
612 if (!m_data_32 && !m_data_64)
614 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
624 ValueObjectSP valobj_sp = m_backend.GetSP();
627 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
630 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
633 m_ptr_size = process_sp->GetAddressByteSize();
634 m_order = process_sp->GetByteOrder();
635 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
636 if (m_ptr_size == 4) {
647 m_data_ptr = data_location + m_ptr_size;
661 if (idx >= num_children)
662 return lldb::ValueObjectSP();
664 if (m_children.empty()) {
671 while (tries < num_children) {
672 key_at_idx = m_data_ptr + (2 * test_idx * m_ptr_size);
673 val_at_idx = key_at_idx + m_ptr_size;
674 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
676 return lldb::ValueObjectSP();
678 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
680 return lldb::ValueObjectSP();
681 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
683 return lldb::ValueObjectSP();
687 if (!key_at_idx || !val_at_idx)
692 lldb::ValueObjectSP()};
694 m_children.push_back(descriptor);
698 if (idx >= m_children.size())
699 return lldb::ValueObjectSP();
703 if (!m_pair_type.IsValid()) {
704 TargetSP target_sp(m_backend.GetTargetSP());
706 return ValueObjectSP();
709 if (!m_pair_type.IsValid())
710 return ValueObjectSP();
712 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
714 if (m_ptr_size == 8) {
715 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
717 *(data_ptr + 1) = dict_item.
val_ptr;
721 *(data_ptr + 1) = dict_item.
val_ptr;
725 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
728 m_exe_ctx_ref, m_pair_type);
749 if (!m_hashtable.IsValid())
751 return m_hashtable.GetCount();
756 ValueObjectSP valobj_sp = m_backend.GetSP();
760 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
762 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
765 m_ptr_size = process_sp->GetAddressByteSize();
766 m_order = process_sp->GetByteOrder();
767 return m_hashtable.Update(valobj_sp->GetValueAsUnsigned(0), m_exe_ctx_ref);
779 lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();
783 if (idx >= num_children)
784 return lldb::ValueObjectSP();
786 if (m_children.empty()) {
787 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
789 return lldb::ValueObjectSP();
801 while (tries < num_children) {
802 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
803 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
805 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
807 return lldb::ValueObjectSP();
808 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
810 return lldb::ValueObjectSP();
814 if (!key_at_idx || !val_at_idx)
819 lldb::ValueObjectSP()};
821 m_children.push_back(descriptor);
825 if (idx >= m_children.size())
826 return lldb::ValueObjectSP();
830 if (!m_pair_type.IsValid()) {
831 TargetSP target_sp(m_backend.GetTargetSP());
833 return ValueObjectSP();
836 if (!m_pair_type.IsValid())
837 return ValueObjectSP();
839 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
841 switch (m_ptr_size) {
843 return lldb::ValueObjectSP();
847 *(data_ptr + 1) = dict_item.
val_ptr;
850 uint64_t *data_ptr =
reinterpret_cast<uint64_t *
>(buffer_sp->GetBytes());
852 *(data_ptr + 1) = dict_item.
val_ptr;
855 lldbassert(
false &&
"pointer size is not 4 nor 8");
859 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
862 m_exe_ctx_ref, m_pair_type);
886 ValueObjectSP valobj_sp = m_backend.GetSP();
889 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
892 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
895 m_ptr_size = process_sp->GetAddressByteSize();
896 m_order = process_sp->GetByteOrder();
897 uint64_t valobj_addr = valobj_sp->GetValueAsUnsigned(0);
898 m_size = process_sp->ReadUnsignedIntegerFromMemory(
899 valobj_addr + 2 * m_ptr_size, m_ptr_size, 0,
error);
903 process_sp->ReadPointerFromMemory(valobj_addr + 3 * m_ptr_size,
error);
907 process_sp->ReadPointerFromMemory(valobj_addr + 4 * m_ptr_size,
error);
908 return !
error.Fail();
920 if (idx >= num_children)
921 return lldb::ValueObjectSP();
923 if (m_children.empty()) {
926 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
928 return lldb::ValueObjectSP();
930 for (
unsigned int child = 0; child < num_children; ++child) {
932 key_at_idx = process_sp->ReadPointerFromMemory(
933 m_keys_ptr + child * m_ptr_size,
error);
935 return lldb::ValueObjectSP();
936 val_at_idx = process_sp->ReadPointerFromMemory(
937 m_objects_ptr + child * m_ptr_size,
error);
939 return lldb::ValueObjectSP();
941 lldb::ValueObjectSP()};
942 m_children.push_back(descriptor);
946 if (idx >= m_children.size())
947 return lldb::ValueObjectSP();
951 if (!m_pair_type.IsValid()) {
952 TargetSP target_sp(m_backend.GetTargetSP());
954 return ValueObjectSP();
957 if (!m_pair_type.IsValid())
958 return ValueObjectSP();
960 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
962 if (m_ptr_size == 8) {
963 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
965 *(data_ptr + 1) = dict_item.
val_ptr;
969 *(data_ptr + 1) = dict_item.
val_ptr;
973 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
976 m_exe_ctx_ref, m_pair_type);
1010 return lldb::ValueObjectSP();
1015 auto process_sp(m_backend.GetProcessSP());
1019 auto ptr_size = process_sp->GetAddressByteSize();
1037 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * ptr_size, 0));
1039 if (ptr_size == 8) {
1040 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1041 *data_ptr = key_at_idx;
1042 *(data_ptr + 1) = value_at_idx;
1045 *data_ptr = key_at_idx;
1046 *(data_ptr + 1) = value_at_idx;
1049 DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size);
1050 m_pair = CreateValueObjectFromData(
1051 "[0]", data, m_backend.GetExecutionContextRef(), pair_type);
1056template <
typename D32,
typename D64>
1060 m_data_32(nullptr), m_data_64(nullptr), m_pair_type() {}
1062template <
typename D32,
typename D64>
1066 m_data_32 =
nullptr;
1068 m_data_64 =
nullptr;
1071template <
typename D32,
typename D64>
1081template <
typename D32,
typename D64>
1084 if (!m_data_32 && !m_data_64)
1086 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
1089template <
typename D32,
typename D64>
1094 ValueObjectSP valobj_sp = m_backend.GetSP();
1097 m_data_32 =
nullptr;
1099 m_data_64 =
nullptr;
1102 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
1105 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
1108 m_ptr_size = process_sp->GetAddressByteSize();
1109 m_order = process_sp->GetByteOrder();
1110 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
1111 if (m_ptr_size == 4) {
1112 m_data_32 =
new D32();
1113 process_sp->ReadMemory(data_location, m_data_32,
sizeof(D32),
1116 m_data_64 =
new D64();
1117 process_sp->ReadMemory(data_location, m_data_64,
sizeof(D64),
1121 return error.Success();
1124template <
typename D32,
typename D64>
1131template <
typename D32,
typename D64>
1134 D32, D64>::GetChildAtIndex(
size_t idx) {
1138 uint32_t size = m_data_32->GetSize();
1139 m_keys_ptr = m_data_32->_buffer;
1140 m_values_ptr = m_data_32->_buffer + (m_ptr_size * size);
1142 uint32_t size = m_data_64->GetSize();
1143 m_keys_ptr = m_data_64->_buffer;
1144 m_values_ptr = m_data_64->_buffer + (m_ptr_size * size);
1149 if (idx >= num_children)
1150 return lldb::ValueObjectSP();
1152 if (m_children.empty()) {
1159 while (tries < num_children) {
1160 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
1161 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
1163 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
1165 return lldb::ValueObjectSP();
1167 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
1169 return lldb::ValueObjectSP();
1170 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
1172 return lldb::ValueObjectSP();
1176 if (!key_at_idx || !val_at_idx)
1181 lldb::ValueObjectSP()};
1183 m_children.push_back(descriptor);
1187 if (idx >= m_children.size())
1188 return lldb::ValueObjectSP();
1192 if (!m_pair_type.IsValid()) {
1193 TargetSP target_sp(m_backend.GetTargetSP());
1195 return ValueObjectSP();
1198 if (!m_pair_type.IsValid())
1199 return ValueObjectSP();
1201 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
1203 if (m_ptr_size == 8) {
1204 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1205 *data_ptr = dict_item.
key_ptr;
1206 *(data_ptr + 1) = dict_item.
val_ptr;
1209 *data_ptr = dict_item.
key_ptr;
1210 *(data_ptr + 1) = dict_item.
val_ptr;
1214 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
1217 m_exe_ctx_ref, m_pair_type);
1229 m_data_32 =
nullptr;
1231 m_data_64 =
nullptr;
1247 if (!m_data_32 && !m_data_64)
1249 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
1256 ValueObjectSP valobj_sp = m_backend.GetSP();
1259 m_data_32 =
nullptr;
1261 m_data_64 =
nullptr;
1264 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
1267 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
1270 m_ptr_size = process_sp->GetAddressByteSize();
1271 m_order = process_sp->GetByteOrder();
1272 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
1273 if (m_ptr_size == 4) {
1283 return error.Success();
1296 (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr);
1298 (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
1302 if (idx >= num_children)
1303 return lldb::ValueObjectSP();
1305 if (m_children.empty()) {
1312 while (tries < num_children) {
1313 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
1314 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
1316 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
1318 return lldb::ValueObjectSP();
1320 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
1322 return lldb::ValueObjectSP();
1323 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
1325 return lldb::ValueObjectSP();
1329 if (!key_at_idx || !val_at_idx)
1334 lldb::ValueObjectSP()};
1336 m_children.push_back(descriptor);
1340 if (idx >= m_children.size())
1341 return lldb::ValueObjectSP();
1345 if (!m_pair_type.IsValid()) {
1346 TargetSP target_sp(m_backend.GetTargetSP());
1348 return ValueObjectSP();
1351 if (!m_pair_type.IsValid())
1352 return ValueObjectSP();
1354 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
1356 if (m_ptr_size == 8) {
1357 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1358 *data_ptr = dict_item.
key_ptr;
1359 *(data_ptr + 1) = dict_item.
val_ptr;
1362 *data_ptr = dict_item.
key_ptr;
1363 *(data_ptr + 1) = dict_item.
val_ptr;
1367 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
1370 m_exe_ctx_ref, m_pair_type);
static llvm::raw_ostream & error(Stream &strm)
static CompilerType GetLLDBNSPairType(TargetSP target_sp)
static size_t CalculateNumChildren(CompilerType container_type, CompilerType element_type, lldb_private::ExecutionContextScope *exe_scope=nullptr)
uint32_t GetFoundationVersion()
bool Update(lldb::addr_t addr, ExecutionContextRef exe_ctx_rf)
std::function< SyntheticChildrenFrontEnd *(CXXSyntheticChildren *, lldb::ValueObjectSP)> CreateFrontEndCallback
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.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
const char * GetCString() const
Get the string value as a C string.
A subclass of DataBuffer that stores a data buffer on the heap.
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
ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value)
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
static lldb::TypeSystemClangSP GetForTarget(Target &target, std::optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
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
static clang::FieldDecl * AddFieldToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &field_type, lldb::AccessType access, uint32_t bitfield_bit_size)
static bool CompleteTagDeclarationDefinition(const CompilerType &type)
static bool StartTagDeclarationDefinition(const CompilerType &type)
lldb::ProcessSP GetProcessSP() const
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
@ eLanguageTypeC
Non-standardized C, such as K&R.
ByteOrder
Byte ordering definitions.