34 return type_system_sp->IsAggregateType(
m_type);
41 return type_system_sp->IsAnonymousType(
m_type);
48 return type_system_sp->IsScopedEnumerationType(
m_type);
53 bool *is_incomplete)
const {
56 return type_system_sp->IsArrayType(
m_type, element_type_ptr, size,
60 element_type_ptr->
Clear();
64 *is_incomplete =
false;
69 uint64_t *size)
const {
72 return type_system_sp->IsVectorType(
m_type, element_type, size);
79 return type_system_sp->IsRuntimeGeneratedType(
m_type);
86 return type_system_sp->IsCharType(
m_type);
93 return type_system_sp->IsCompleteType(
m_type);
100 return type_system_sp->IsForcefullyCompleted(
m_type);
107 return type_system_sp->IsConst(
m_type);
114 return type_system_sp->IsFunctionType(
m_type);
123 return type_system_sp->IsHomogeneousAggregate(
m_type, base_type_ptr);
130 return type_system_sp->GetNumberOfFunctionArguments(
m_type);
145 return type_system_sp->IsFunctionPointerType(
m_type);
152 return type_system_sp->IsMemberFunctionPointerType(
m_type);
160 return type_system_sp->IsBlockPointerType(
m_type, function_pointer_type_ptr);
167 return type_system_sp->IsIntegerType(
m_type, is_signed);
174 return type_system_sp->IsEnumerationType(
m_type, is_signed);
185 return type_system_sp->IsPointerType(
m_type, pointee_type);
188 pointee_type->
Clear();
195 return type_system_sp->IsPointerOrReferenceType(
m_type, pointee_type);
198 pointee_type->
Clear();
203 bool *is_rvalue)
const {
206 return type_system_sp->IsReferenceType(
m_type, pointee_type, is_rvalue);
209 pointee_type->
Clear();
216 return type_system_sp->ShouldTreatScalarValueAsAddress(
m_type);
221 bool &is_complex)
const {
224 return type_system_sp->IsFloatingPointType(
m_type, count, is_complex);
234 return type_system_sp->IsDefined(
m_type);
241 return type_system_sp->IsPolymorphicClass(
m_type);
247 bool check_cplusplus,
248 bool check_objc)
const {
251 return type_system_sp->IsPossibleDynamicType(
m_type, dynamic_pointee_type,
252 check_cplusplus, check_objc);
259 return type_system_sp->IsScalarType(
m_type);
266 return type_system_sp->IsTemplateType(
m_type);
273 return type_system_sp->IsTypedefType(
m_type);
280 return type_system_sp->IsVoidType(
m_type);
301 return type_system_sp->IsBeingDefined(
m_type);
306 bool is_signed =
false;
312 bool is_complex =
false;
317 bool is_signed =
false;
377 llvm_unreachable(
"All cases handled above.");
393 (lldb::eTypeClassClass | lldb::eTypeClassStruct |
394 lldb::eTypeClassUnion);
399 bool carry_virtual)
const {
401 return carry_virtual;
403 if (!carry_virtual) {
405 for (uint32_t i = 0; i < num_virtual_bases; ++i) {
408 if (base.IsVirtualBase(target_base, virtual_base,
411 *virtual_base = base;
419 for (uint32_t i = 0; i < num_direct_bases; ++i) {
422 if (base.IsVirtualBase(target_base, virtual_base, carry_virtual))
442 if (name.IsEmpty() || canonical_name.IsEmpty())
445 if (name == canonical_name)
446 return llvm::formatv(
"'{0}'", name);
448 return llvm::formatv(
"'{0}' (canonically referred to as '{1}')", name,
458 return name == rhs_name;
463 case lldb::eTypeClassClass:
465 case lldb::eTypeClassEnumeration:
467 case lldb::eTypeClassStruct:
469 case lldb::eTypeClassUnion:
474 llvm_unreachable(
"All cases are covered by code above.");
481 for (uint32_t i = 0; i < num_direct_bases; ++i) {
496 return type_system_sp->GetCompleteType(
m_type);
503 return type_system_sp->GetPointerByteSize();
510 return type_system_sp->GetTypeName(
m_type, BaseOnly);
518 return type_system_sp->GetDisplayTypeName(
m_type);
526 return type_system_sp->GetTypeInfo(
m_type,
527 pointee_or_element_compiler_type);
534 return type_system_sp->GetMinimumLanguage(
m_type);
541 return type_system_sp->GetTypeClass(
m_type);
542 return lldb::eTypeClassInvalid;
560 return type_system_sp->GetTypeQualifiers(
m_type);
607 return type_system_sp->GetFunctionArgumentCount(
m_type);
631 return type_system_sp->GetNumMemberFunctions(
m_type);
639 return type_system_sp->GetMemberFunctionAtIndex(
m_type, idx);
711 uint32_t payload)
const {
736std::optional<uint64_t>
740 return type_system_sp->GetBitSize(
m_type, exe_scope);
744std::optional<uint64_t>
746 if (std::optional<uint64_t> bit_size =
GetBitSize(exe_scope))
747 return (*bit_size + 7) / 8;
755 return type_system_sp->GetTypeBitAlign(
m_type, exe_scope);
762 return type_system_sp->GetEncoding(
m_type, count);
769 return type_system_sp->GetFormat(
m_type);
773llvm::Expected<uint32_t>
778 return type_system_sp->GetNumChildren(
m_type, omit_empty_base_classes,
780 return llvm::make_error<llvm::StringError>(
"invalid type",
781 llvm::inconvertibleErrorCode());
787 return type_system_sp->GetBasicTypeEnumeration(
m_type);
794 const llvm::APSInt &value)>
const &callback)
const {
797 return type_system_sp->ForEachEnumerator(
m_type, callback);
803 return type_system_sp->GetNumFields(
m_type);
808 uint64_t *bit_offset_ptr,
809 uint32_t *bitfield_bit_size_ptr,
810 bool *is_bitfield_ptr)
const {
814 bitfield_bit_size_ptr, is_bitfield_ptr);
821 return type_system_sp->GetNumDirectBaseClasses(
m_type);
828 return type_system_sp->GetNumVirtualBaseClasses(
m_type);
834 uint32_t *bit_offset_ptr)
const {
844 uint32_t *bit_offset_ptr)
const {
853 const char *name,
CompilerType *field_compiler_type_ptr,
854 uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr,
855 bool *is_bitfield_ptr)
const {
857 std::string field_name;
858 for (
unsigned index = 0; index < count; index++) {
861 bitfield_bit_size_ptr, is_bitfield_ptr));
862 if (strcmp(field_name.c_str(), name) == 0) {
863 if (field_compiler_type_ptr)
864 *field_compiler_type_ptr = field_compiler_type;
873 bool omit_empty_base_classes,
bool ignore_array_bounds,
874 std::string &child_name, uint32_t &child_byte_size,
875 int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
876 uint32_t &child_bitfield_bit_offset,
bool &child_is_base_class,
877 bool &child_is_deref_of_parent,
ValueObject *valobj,
878 uint64_t &language_flags)
const {
882 m_type, exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
883 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
884 child_bitfield_bit_size, child_bitfield_bit_offset,
885 child_is_base_class, child_is_deref_of_parent, valobj,
924 llvm::StringRef name,
bool omit_empty_base_classes,
925 std::vector<uint32_t> &child_indexes)
const {
926 if (
IsValid() && !name.empty()) {
928 return type_system_sp->GetIndexOfChildMemberWithName(
929 m_type, name, omit_empty_base_classes, child_indexes);
937 return type_system_sp->GetNumTemplateArguments(
m_type, expand_pack);
946 return type_system_sp->GetTemplateArgumentKind(
m_type, idx, expand_pack);
951 bool expand_pack)
const {
959std::optional<CompilerType::IntegralTemplateArgument>
963 return type_system_sp->GetIntegralTemplateArgument(
m_type, idx, expand_pack);
977 return type_system_sp->ShouldPrintAsOneLiner(
m_type, valobj);
984 return type_system_sp->IsMeaninglessWithoutDynamicResolution(
m_type);
994 bool omit_empty_base_classes)
const {
995 if (
IsValid() && !name.empty()) {
997 return type_system_sp->GetIndexOfChildWithName(
m_type, name,
998 omit_empty_base_classes);
1008 uint32_t bitfield_bit_size,
1009 uint32_t bitfield_bit_offset,
1013 return type_system_sp->DumpTypeValue(
1014 m_type, *s, format, data, byte_offset, byte_size, bitfield_bit_size,
1015 bitfield_bit_offset, exe_scope);
1022 type_system_sp->DumpTypeDescription(
m_type, level);
1029 type_system_sp->DumpTypeDescription(
m_type, *s, level);
1036 return type_system_sp->dump(
m_type);
1037 llvm::errs() <<
"<invalid>\n";
1043 size_t data_byte_size,
Scalar &value,
1057 std::optional<uint64_t> byte_size =
GetByteSize(exe_scope);
1067 if (*byte_size <=
sizeof(
unsigned long long)) {
1068 uint64_t uval64 = data.
GetMaxU64(&offset, *byte_size);
1069 if (*byte_size <=
sizeof(
unsigned int)) {
1070 value = (
unsigned int)uval64;
1072 }
else if (*byte_size <=
sizeof(
unsigned long)) {
1073 value = (
unsigned long)uval64;
1075 }
else if (*byte_size <=
sizeof(
unsigned long long)) {
1076 value = (
unsigned long long)uval64;
1084 if (*byte_size <=
sizeof(
long long)) {
1085 int64_t sval64 = data.
GetMaxS64(&offset, *byte_size);
1086 if (*byte_size <=
sizeof(
int)) {
1087 value = (int)sval64;
1089 }
else if (*byte_size <=
sizeof(
long)) {
1090 value = (long)sval64;
1092 }
else if (*byte_size <=
sizeof(
long long)) {
1093 value = (
long long)sval64;
1101 if (*byte_size <=
sizeof(
long double)) {
1104 if (*byte_size ==
sizeof(
float)) {
1105 if (
sizeof(
float) ==
sizeof(uint32_t)) {
1106 u32 = data.
GetU32(&offset);
1107 value = *((
float *)&u32);
1109 }
else if (
sizeof(
float) ==
sizeof(uint64_t)) {
1110 u64 = data.
GetU64(&offset);
1111 value = *((
float *)&u64);
1114 }
else if (*byte_size ==
sizeof(
double)) {
1115 if (
sizeof(
double) ==
sizeof(uint32_t)) {
1116 u32 = data.
GetU32(&offset);
1117 value = *((
double *)&u32);
1119 }
else if (
sizeof(
double) ==
sizeof(uint64_t)) {
1120 u64 = data.
GetU64(&offset);
1121 value = *((
double *)&u64);
1124 }
else if (*byte_size ==
sizeof(
long double)) {
1125 if (
sizeof(
long double) ==
sizeof(uint32_t)) {
1126 u32 = data.
GetU32(&offset);
1127 value = *((
long double *)&u32);
1129 }
else if (
sizeof(
long double) ==
sizeof(uint64_t)) {
1130 u64 = data.
GetU64(&offset);
1131 value = *((
long double *)&u64);
1144 : m_type_system(type_system.GetSharedPointer()), m_type(type) {
1145 assert(
Verify() &&
"verification failed");
1150 : m_type_system(type_system), m_type(type) {
1151 assert(
Verify() &&
"verification failed");
1159 return type_system_sp->Verify(
m_type);
1178 assert(m_typesystem_sp);
1179 return m_typesystem_sp.get();
1190 return !(lhs == rhs);
Represents a generic declaration context in a program.
This is a minimal wrapper of a TypeSystem shared pointer as returned by CompilerType which conventien...
lldb::TypeSystemSP GetSharedPointer() const
bool operator==(const TypeSystemSPWrapper &other) const
lldb::TypeSystemSP m_typesystem_sp
TypeSystem * operator->() const
Only to be used in a one-off situations like if (typesystem && typesystem->method()) Do not store thi...
Generic representation of a type in a programming language.
uint32_t GetNumberOfNonEmptyBaseClasses()
Go through the base classes and count non-empty ones.
CompilerType GetTypeForFormatters() const
CompilerType GetTypeTemplateArgument(size_t idx, bool expand_pack=false) const
lldb::LanguageType GetMinimumLanguage()
bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, Scalar &value, ExecutionContextScope *exe_scope) const
bool Verify() const
If the type is valid, ask the TypeSystem to verify the integrity of the type to catch CompilerTypes t...
lldb::BasicType GetBasicTypeEnumeration() const
std::optional< IntegralTemplateArgument > GetIntegralTemplateArgument(size_t idx, bool expand_pack=false) const
Returns the value of the template argument and its type.
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
CompilerType GetArrayType(uint64_t size) const
CompilerType GetChildCompilerTypeAtIndex(ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj, uint64_t &language_flags) const
CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const
Create related types using the current type's AST.
bool IsPossibleDynamicType(CompilerType *target_type, bool check_cplusplus, bool check_objc) const
void SetCompilerType(lldb::TypeSystemWP type_system, lldb::opaque_compiler_type_t type)
std::optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
CompilerType AddConstModifier() const
Return a new CompilerType adds a const modifier to this type if this type is valid and the type syste...
lldb::Encoding GetEncoding(uint64_t &count) const
bool IsArrayType(CompilerType *element_type=nullptr, uint64_t *size=nullptr, bool *is_incomplete=nullptr) const
ConstString GetDisplayTypeName() const
CompilerType GetVirtualBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
size_t GetNumMemberFunctions() const
CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const
uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const
CompilerType GetFieldAtIndex(size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) const
bool IsCompleteType() const
CompilerType GetRValueReferenceType() const
Return a new CompilerType that is a R value reference to this type if this type is valid and the type...
bool IsIntegerOrUnscopedEnumerationType() const
size_t GetIndexOfChildMemberWithName(llvm::StringRef name, bool omit_empty_base_classes, std::vector< uint32_t > &child_indexes) const
Lookup a child member given a name.
bool IsScalarOrUnscopedEnumerationType() const
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
bool IsContextuallyConvertibleToBool() const
This may only be defined in TypeSystemClang.
lldb::TypeClass GetTypeClass() const
lldb::opaque_compiler_type_t GetOpaqueQualType() const
size_t GetNumTemplateArguments(bool expand_pack=false) const
Return the number of template arguments the type has.
CompilerType AddVolatileModifier() const
Return a new CompilerType adds a volatile modifier to this type if this type is valid and the type sy...
bool IsVirtualBase(CompilerType target_base, CompilerType *virtual_base, bool carry_virtual=false) const
Checks whether target_base is a virtual base of type (direct or indirect).
CompilerType AddRestrictModifier() const
Return a new CompilerType adds a restrict modifier to this type if this type is valid and the type sy...
bool IsPointerToVoid() const
bool IsBeingDefined() const
lldb::TypeSystemWP m_type_system
uint32_t GetNumVirtualBaseClasses() const
size_t GetPointerByteSize() const
AST related queries.
CompilerType GetFunctionArgumentAtIndex(const size_t index) const
void ForEachEnumerator(std::function< bool(const CompilerType &integer_type, ConstString name, const llvm::APSInt &value)> const &callback) const
If this type is an enumeration, iterate through all of its enumerators using a callback.
bool IsFloatingPointType(uint32_t &count, bool &is_complex) const
LLVM_DUMP_METHOD void dump() const
Dumping types.
CompilerType GetLValueReferenceType() const
Return a new CompilerType that is a L value reference to this type if this type is valid and the type...
uint32_t GetNumFields() const
bool IsPromotableIntegerType() const
size_t GetNumberOfFunctionArguments() const
bool IsIntegerOrEnumerationType(bool &is_signed) const
bool IsScopedEnumerationType() const
bool ShouldTreatScalarValueAsAddress() const
CompilerType GetNonReferenceType() const
If this type is a reference to a type (L value or R value reference), return a new type with the refe...
uint32_t GetNumDirectBaseClasses() const
bool IsMeaninglessWithoutDynamicResolution() const
bool IsBlockPointerType(CompilerType *function_pointer_type_ptr=nullptr) const
bool IsAnonymousType() const
ConstString GetTypeName(bool BaseOnly=false) const
uint32_t GetIndexOfChildWithName(llvm::StringRef name, bool omit_empty_base_classes) const
Lookup a child given a name.
bool IsEnumerationIntegerTypeSigned() const
CompilerType GetTypedefedType() const
If the current object represents a typedef type, get the underlying type.
bool IsReferenceType(CompilerType *pointee_type=nullptr, bool *is_rvalue=nullptr) const
bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope)
bool IsArrayOfScalarType() const
std::string TypeDescription()
bool IsAggregateType() const
CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const
Creating related types.
bool IsInteger() const
This is used when you don't care about the signedness of the integer.
lldb::Format GetFormat() const
CompilerType GetFullyUnqualifiedType() const
unsigned GetTypeQualifiers() const
CompilerType GetDirectBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
std::optional< size_t > GetTypeBitAlign(ExecutionContextScope *exe_scope) const
const char * GetTypeTag()
bool IsFunctionPointerType() const
CompilerType GetPointeeType() const
If this type is a pointer type, return the type that the pointer points to, else return an invalid ty...
bool IsIntegerType(bool &is_signed) const
bool GetCompleteType() const
Type Completion.
bool IsUnscopedEnumerationType() const
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
int GetFunctionArgumentCount() const
Returns -1 if this isn't a function of if the function doesn't have a prototype Returns a value >= 0 ...
std::optional< uint64_t > GetBitSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bits.
uint32_t GetIndexOfFieldWithName(const char *name, CompilerType *field_compiler_type=nullptr, uint64_t *bit_offset_ptr=nullptr, uint32_t *bitfield_bit_size_ptr=nullptr, bool *is_bitfield_ptr=nullptr) const
llvm::Expected< uint32_t > GetNumChildren(bool omit_empty_base_classes, const ExecutionContext *exe_ctx) const
bool IsFunctionType() const
CompilerType GetEnumerationIntegerType() const
lldb::opaque_compiler_type_t m_type
bool CompareTypes(CompilerType rhs) const
bool IsScalarType() const
bool IsForcefullyCompleted() const
bool IsEnumerationType() const
This is used when you don't care about the signedness of the enum.
bool IsPolymorphicClass() const
CompilerType CreateTypedef(const char *name, const CompilerDeclContext &decl_ctx, uint32_t payload) const
Create a typedef to this type using "name" as the name of the typedef this type is valid and the type...
bool IsTypedefType() const
CompilerType GetFunctionReturnType() const
bool IsRecordType() const
bool IsVectorType(CompilerType *element_type=nullptr, uint64_t *size=nullptr) const
bool IsMemberFunctionPointerType() const
CompilerType GetAtomicType() const
Return a new CompilerType that is the atomic type of this type.
bool IsTemplateType() const
bool IsNullPtrType() const
CompilerType GetCanonicalType() const
void DumpTypeDescription(lldb::DescriptionLevel level=lldb::eDescriptionLevelFull) const
Dump to stdout.
bool IsRuntimeGeneratedType() const
lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx, bool expand_pack=false) const
LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const
TypeMemberFunctionImpl GetMemberFunctionAtIndex(size_t idx)
bool IsPointerOrReferenceType(CompilerType *pointee_type=nullptr) const
bool IsPointerToScalarType() const
bool IsPointerType(CompilerType *pointee_type=nullptr) const
A uniqued constant string class.
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A stream class that can stream formatted output to a file.
Interface for representing a type system.
A class that represents a running process on the host machine.
bool operator!=(const Address &lhs, const Address &rhs)
bool operator==(const Address &lhs, const Address &rhs)
void * opaque_compiler_type_t
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
@ eBasicTypeUnsignedShort
@ eBasicTypeUnsignedWChar
Format
Display format definitions.
LanguageType
Programming language type.
@ eLanguageTypeC
Non-standardized C, such as K&R.
@ eTemplateArgumentKindNull
Encoding
Register encoding definitions.
@ eEncodingVector
vector registers
@ eEncodingUint
unsigned integer
@ eEncodingSint
signed integer
std::weak_ptr< lldb_private::TypeSystem > TypeSystemWP