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>
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 std::string prefix, suffix;
506 if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
513 stream.
Printf(
"%s%" PRIu64
" %s%s%s", prefix.c_str(), value,
"key/value pair",
514 value == 1 ?
"" :
"s", suffix.c_str());
521 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
532 if (flags.
IsClear(eTypeIsPointer)) {
534 valobj_sp = valobj_sp->AddressOf(
error);
535 if (
error.Fail() || !valobj_sp)
542 if (!descriptor || !descriptor->IsValid())
545 ConstString class_name(descriptor->GetClassName());
547 static const ConstString g_DictionaryI(
"__NSDictionaryI");
548 static const ConstString g_DictionaryM(
"__NSDictionaryM");
549 static const ConstString g_Dictionary1(
"__NSSingleEntryDictionaryI");
550 static const ConstString g_DictionaryImmutable(
"__NSDictionaryM_Immutable");
551 static const ConstString g_DictionaryMFrozen(
"__NSFrozenDictionaryM");
552 static const ConstString g_DictionaryMLegacy(
"__NSDictionaryM_Legacy");
553 static const ConstString g_Dictionary0(
"__NSDictionary0");
554 static const ConstString g_DictionaryCF(
"__CFDictionary");
555 static const ConstString g_DictionaryNSCF(
"__NSCFDictionary");
556 static const ConstString g_DictionaryCFRef(
"CFDictionaryRef");
557 static const ConstString g_ConstantDictionary(
"NSConstantDictionary");
562 if (class_name == g_DictionaryI) {
564 }
else if (class_name == g_ConstantDictionary) {
566 }
else if (class_name == g_DictionaryM || class_name == g_DictionaryMFrozen) {
574 }
else if (class_name == g_DictionaryMLegacy) {
576 }
else if (class_name == g_Dictionary1) {
578 }
else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||
579 class_name == g_DictionaryCFRef) {
583 for (
auto &candidate : map) {
584 if (candidate.first && candidate.first->Match((class_name)))
585 return candidate.second(synth, valobj_sp);
615 if (!m_data_32 && !m_data_64)
617 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
627 ValueObjectSP valobj_sp = m_backend.GetSP();
630 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
633 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
636 m_ptr_size = process_sp->GetAddressByteSize();
637 m_order = process_sp->GetByteOrder();
638 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
639 if (m_ptr_size == 4) {
650 m_data_ptr = data_location + m_ptr_size;
664 if (idx >= num_children)
665 return lldb::ValueObjectSP();
667 if (m_children.empty()) {
674 while (tries < num_children) {
675 key_at_idx = m_data_ptr + (2 * test_idx * m_ptr_size);
676 val_at_idx = key_at_idx + m_ptr_size;
677 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
679 return lldb::ValueObjectSP();
681 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
683 return lldb::ValueObjectSP();
684 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
686 return lldb::ValueObjectSP();
690 if (!key_at_idx || !val_at_idx)
695 lldb::ValueObjectSP()};
697 m_children.push_back(descriptor);
701 if (idx >= m_children.size())
702 return lldb::ValueObjectSP();
706 if (!m_pair_type.IsValid()) {
707 TargetSP target_sp(m_backend.GetTargetSP());
709 return ValueObjectSP();
712 if (!m_pair_type.IsValid())
713 return ValueObjectSP();
715 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
717 if (m_ptr_size == 8) {
718 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
720 *(data_ptr + 1) = dict_item.
val_ptr;
724 *(data_ptr + 1) = dict_item.
val_ptr;
728 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
731 m_exe_ctx_ref, m_pair_type);
752 if (!m_hashtable.IsValid())
754 return m_hashtable.GetCount();
759 ValueObjectSP valobj_sp = m_backend.GetSP();
763 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
765 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
768 m_ptr_size = process_sp->GetAddressByteSize();
769 m_order = process_sp->GetByteOrder();
770 return m_hashtable.Update(valobj_sp->GetValueAsUnsigned(0), m_exe_ctx_ref);
782 lldb::addr_t m_values_ptr = m_hashtable.GetValuePointer();
786 if (idx >= num_children)
787 return lldb::ValueObjectSP();
789 if (m_children.empty()) {
790 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
792 return lldb::ValueObjectSP();
804 while (tries < num_children) {
805 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
806 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
808 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
810 return lldb::ValueObjectSP();
811 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
813 return lldb::ValueObjectSP();
817 if (!key_at_idx || !val_at_idx)
822 lldb::ValueObjectSP()};
824 m_children.push_back(descriptor);
828 if (idx >= m_children.size())
829 return lldb::ValueObjectSP();
833 if (!m_pair_type.IsValid()) {
834 TargetSP target_sp(m_backend.GetTargetSP());
836 return ValueObjectSP();
839 if (!m_pair_type.IsValid())
840 return ValueObjectSP();
842 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
844 switch (m_ptr_size) {
846 return lldb::ValueObjectSP();
850 *(data_ptr + 1) = dict_item.
val_ptr;
853 uint64_t *data_ptr =
reinterpret_cast<uint64_t *
>(buffer_sp->GetBytes());
855 *(data_ptr + 1) = dict_item.
val_ptr;
858 lldbassert(
false &&
"pointer size is not 4 nor 8");
862 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
865 m_exe_ctx_ref, m_pair_type);
889 ValueObjectSP valobj_sp = m_backend.GetSP();
892 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
895 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
898 m_ptr_size = process_sp->GetAddressByteSize();
899 m_order = process_sp->GetByteOrder();
900 uint64_t valobj_addr = valobj_sp->GetValueAsUnsigned(0);
901 m_size = process_sp->ReadUnsignedIntegerFromMemory(
902 valobj_addr + 2 * m_ptr_size, m_ptr_size, 0,
error);
906 process_sp->ReadPointerFromMemory(valobj_addr + 3 * m_ptr_size,
error);
910 process_sp->ReadPointerFromMemory(valobj_addr + 4 * m_ptr_size,
error);
911 return !
error.Fail();
923 if (idx >= num_children)
924 return lldb::ValueObjectSP();
926 if (m_children.empty()) {
929 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
931 return lldb::ValueObjectSP();
933 for (
unsigned int child = 0; child < num_children; ++child) {
935 key_at_idx = process_sp->ReadPointerFromMemory(
936 m_keys_ptr + child * m_ptr_size,
error);
938 return lldb::ValueObjectSP();
939 val_at_idx = process_sp->ReadPointerFromMemory(
940 m_objects_ptr + child * m_ptr_size,
error);
942 return lldb::ValueObjectSP();
944 lldb::ValueObjectSP()};
945 m_children.push_back(descriptor);
949 if (idx >= m_children.size())
950 return lldb::ValueObjectSP();
954 if (!m_pair_type.IsValid()) {
955 TargetSP target_sp(m_backend.GetTargetSP());
957 return ValueObjectSP();
960 if (!m_pair_type.IsValid())
961 return ValueObjectSP();
963 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
965 if (m_ptr_size == 8) {
966 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
968 *(data_ptr + 1) = dict_item.
val_ptr;
972 *(data_ptr + 1) = dict_item.
val_ptr;
976 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
979 m_exe_ctx_ref, m_pair_type);
1013 return lldb::ValueObjectSP();
1018 auto process_sp(m_backend.GetProcessSP());
1022 auto ptr_size = process_sp->GetAddressByteSize();
1040 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * ptr_size, 0));
1042 if (ptr_size == 8) {
1043 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1044 *data_ptr = key_at_idx;
1045 *(data_ptr + 1) = value_at_idx;
1048 *data_ptr = key_at_idx;
1049 *(data_ptr + 1) = value_at_idx;
1052 DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size);
1053 m_pair = CreateValueObjectFromData(
1054 "[0]", data, m_backend.GetExecutionContextRef(), pair_type);
1059template <
typename D32,
typename D64>
1063 m_data_32(nullptr), m_data_64(nullptr), m_pair_type() {}
1065template <
typename D32,
typename D64>
1069 m_data_32 =
nullptr;
1071 m_data_64 =
nullptr;
1074template <
typename D32,
typename D64>
1084template <
typename D32,
typename D64>
1087 if (!m_data_32 && !m_data_64)
1089 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
1092template <
typename D32,
typename D64>
1097 ValueObjectSP valobj_sp = m_backend.GetSP();
1100 m_data_32 =
nullptr;
1102 m_data_64 =
nullptr;
1105 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
1108 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
1111 m_ptr_size = process_sp->GetAddressByteSize();
1112 m_order = process_sp->GetByteOrder();
1113 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
1114 if (m_ptr_size == 4) {
1115 m_data_32 =
new D32();
1116 process_sp->ReadMemory(data_location, m_data_32,
sizeof(D32),
1119 m_data_64 =
new D64();
1120 process_sp->ReadMemory(data_location, m_data_64,
sizeof(D64),
1124 return error.Success();
1127template <
typename D32,
typename D64>
1134template <
typename D32,
typename D64>
1137 D32, D64>::GetChildAtIndex(
size_t idx) {
1141 uint32_t size = m_data_32->GetSize();
1142 m_keys_ptr = m_data_32->_buffer;
1143 m_values_ptr = m_data_32->_buffer + (m_ptr_size * size);
1145 uint32_t size = m_data_64->GetSize();
1146 m_keys_ptr = m_data_64->_buffer;
1147 m_values_ptr = m_data_64->_buffer + (m_ptr_size * size);
1152 if (idx >= num_children)
1153 return lldb::ValueObjectSP();
1155 if (m_children.empty()) {
1162 while (tries < num_children) {
1163 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
1164 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
1166 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
1168 return lldb::ValueObjectSP();
1170 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
1172 return lldb::ValueObjectSP();
1173 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
1175 return lldb::ValueObjectSP();
1179 if (!key_at_idx || !val_at_idx)
1184 lldb::ValueObjectSP()};
1186 m_children.push_back(descriptor);
1190 if (idx >= m_children.size())
1191 return lldb::ValueObjectSP();
1195 if (!m_pair_type.IsValid()) {
1196 TargetSP target_sp(m_backend.GetTargetSP());
1198 return ValueObjectSP();
1201 if (!m_pair_type.IsValid())
1202 return ValueObjectSP();
1204 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
1206 if (m_ptr_size == 8) {
1207 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1208 *data_ptr = dict_item.
key_ptr;
1209 *(data_ptr + 1) = dict_item.
val_ptr;
1212 *data_ptr = dict_item.
key_ptr;
1213 *(data_ptr + 1) = dict_item.
val_ptr;
1217 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
1220 m_exe_ctx_ref, m_pair_type);
1232 m_data_32 =
nullptr;
1234 m_data_64 =
nullptr;
1250 if (!m_data_32 && !m_data_64)
1252 return (m_data_32 ? m_data_32->_used : m_data_64->_used);
1259 ValueObjectSP valobj_sp = m_backend.GetSP();
1262 m_data_32 =
nullptr;
1264 m_data_64 =
nullptr;
1267 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
1270 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
1273 m_ptr_size = process_sp->GetAddressByteSize();
1274 m_order = process_sp->GetByteOrder();
1275 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
1276 if (m_ptr_size == 4) {
1286 return error.Success();
1299 (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr);
1301 (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
1305 if (idx >= num_children)
1306 return lldb::ValueObjectSP();
1308 if (m_children.empty()) {
1315 while (tries < num_children) {
1316 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
1317 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);
1319 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
1321 return lldb::ValueObjectSP();
1323 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx,
error);
1325 return lldb::ValueObjectSP();
1326 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx,
error);
1328 return lldb::ValueObjectSP();
1332 if (!key_at_idx || !val_at_idx)
1337 lldb::ValueObjectSP()};
1339 m_children.push_back(descriptor);
1343 if (idx >= m_children.size())
1344 return lldb::ValueObjectSP();
1348 if (!m_pair_type.IsValid()) {
1349 TargetSP target_sp(m_backend.GetTargetSP());
1351 return ValueObjectSP();
1354 if (!m_pair_type.IsValid())
1355 return ValueObjectSP();
1357 WritableDataBufferSP buffer_sp(
new DataBufferHeap(2 * m_ptr_size, 0));
1359 if (m_ptr_size == 8) {
1360 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
1361 *data_ptr = dict_item.
key_ptr;
1362 *(data_ptr + 1) = dict_item.
val_ptr;
1365 *data_ptr = dict_item.
key_ptr;
1366 *(data_ptr + 1) = dict_item.
val_ptr;
1370 idx_name.
Printf(
"[%" PRIu64
"]", (uint64_t)idx);
1373 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.