| //===-- CompilerType.cpp ----------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Symbol/CompilerType.h" |
| |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/Scalar.h" |
| #include "lldb/Core/StreamFile.h" |
| #include "lldb/Symbol/ClangASTContext.h" |
| #include "lldb/Symbol/ClangExternalASTSourceCommon.h" |
| #include "lldb/Symbol/Type.h" |
| #include "lldb/Target/ExecutionContext.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Utility/ConstString.h" |
| #include "lldb/Utility/DataBufferHeap.h" |
| #include "lldb/Utility/DataExtractor.h" |
| #include "lldb/Utility/Stream.h" |
| #include "lldb/Utility/StreamString.h" |
| |
| #include <iterator> |
| #include <mutex> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| CompilerType::CompilerType(TypeSystem *type_system, |
| lldb::opaque_compiler_type_t type) |
| : m_type(type), m_type_system(type_system) {} |
| |
| CompilerType::CompilerType(clang::ASTContext *ast, clang::QualType qual_type) |
| : m_type(qual_type.getAsOpaquePtr()), |
| m_type_system(ClangASTContext::GetASTContext(ast)) { |
| #ifdef LLDB_CONFIGURATION_DEBUG |
| if (m_type) |
| assert(m_type_system != nullptr); |
| #endif |
| } |
| |
| CompilerType::~CompilerType() {} |
| |
| //---------------------------------------------------------------------- |
| // Tests |
| //---------------------------------------------------------------------- |
| |
| bool CompilerType::IsAggregateType() const { |
| if (IsValid()) |
| return m_type_system->IsAggregateType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsAnonymousType() const { |
| if (IsValid()) |
| return m_type_system->IsAnonymousType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsArrayType(CompilerType *element_type_ptr, uint64_t *size, |
| bool *is_incomplete) const { |
| if (IsValid()) |
| return m_type_system->IsArrayType(m_type, element_type_ptr, size, |
| is_incomplete); |
| |
| if (element_type_ptr) |
| element_type_ptr->Clear(); |
| if (size) |
| *size = 0; |
| if (is_incomplete) |
| *is_incomplete = false; |
| return false; |
| } |
| |
| bool CompilerType::IsVectorType(CompilerType *element_type, |
| uint64_t *size) const { |
| if (IsValid()) |
| return m_type_system->IsVectorType(m_type, element_type, size); |
| return false; |
| } |
| |
| bool CompilerType::IsRuntimeGeneratedType() const { |
| if (IsValid()) |
| return m_type_system->IsRuntimeGeneratedType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsCharType() const { |
| if (IsValid()) |
| return m_type_system->IsCharType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsCompleteType() const { |
| if (IsValid()) |
| return m_type_system->IsCompleteType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsConst() const { |
| if (IsValid()) |
| return m_type_system->IsConst(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsCStringType(uint32_t &length) const { |
| if (IsValid()) |
| return m_type_system->IsCStringType(m_type, length); |
| return false; |
| } |
| |
| bool CompilerType::IsFunctionType(bool *is_variadic_ptr) const { |
| if (IsValid()) |
| return m_type_system->IsFunctionType(m_type, is_variadic_ptr); |
| return false; |
| } |
| |
| // Used to detect "Homogeneous Floating-point Aggregates" |
| uint32_t |
| CompilerType::IsHomogeneousAggregate(CompilerType *base_type_ptr) const { |
| if (IsValid()) |
| return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr); |
| return 0; |
| } |
| |
| size_t CompilerType::GetNumberOfFunctionArguments() const { |
| if (IsValid()) |
| return m_type_system->GetNumberOfFunctionArguments(m_type); |
| return 0; |
| } |
| |
| CompilerType |
| CompilerType::GetFunctionArgumentAtIndex(const size_t index) const { |
| if (IsValid()) |
| return m_type_system->GetFunctionArgumentAtIndex(m_type, index); |
| return CompilerType(); |
| } |
| |
| bool CompilerType::IsFunctionPointerType() const { |
| if (IsValid()) |
| return m_type_system->IsFunctionPointerType(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsBlockPointerType( |
| CompilerType *function_pointer_type_ptr) const { |
| if (IsValid()) |
| return m_type_system->IsBlockPointerType(m_type, function_pointer_type_ptr); |
| return 0; |
| } |
| |
| bool CompilerType::IsIntegerType(bool &is_signed) const { |
| if (IsValid()) |
| return m_type_system->IsIntegerType(m_type, is_signed); |
| return false; |
| } |
| |
| bool CompilerType::IsEnumerationType(bool &is_signed) const { |
| if (IsValid()) |
| return m_type_system->IsEnumerationType(m_type, is_signed); |
| return false; |
| } |
| |
| bool CompilerType::IsIntegerOrEnumerationType(bool &is_signed) const { |
| return IsIntegerType(is_signed) || IsEnumerationType(is_signed); |
| } |
| |
| bool CompilerType::IsPointerType(CompilerType *pointee_type) const { |
| if (IsValid()) { |
| return m_type_system->IsPointerType(m_type, pointee_type); |
| } |
| if (pointee_type) |
| pointee_type->Clear(); |
| return false; |
| } |
| |
| bool CompilerType::IsPointerOrReferenceType(CompilerType *pointee_type) const { |
| if (IsValid()) { |
| return m_type_system->IsPointerOrReferenceType(m_type, pointee_type); |
| } |
| if (pointee_type) |
| pointee_type->Clear(); |
| return false; |
| } |
| |
| bool CompilerType::IsReferenceType(CompilerType *pointee_type, |
| bool *is_rvalue) const { |
| if (IsValid()) { |
| return m_type_system->IsReferenceType(m_type, pointee_type, is_rvalue); |
| } |
| if (pointee_type) |
| pointee_type->Clear(); |
| return false; |
| } |
| |
| bool CompilerType::ShouldTreatScalarValueAsAddress() const { |
| if (IsValid()) |
| return m_type_system->ShouldTreatScalarValueAsAddress(m_type); |
| return false; |
| } |
| |
| bool CompilerType::IsFloatingPointType(uint32_t &count, |
| bool &is_complex) const { |
| if (IsValid()) { |
| return m_type_system->IsFloatingPointType(m_type, count, is_complex); |
| } |
| count = 0; |
| is_complex = false; |
| return false; |
| } |
| |
| bool CompilerType::IsDefined() const { |
| if (IsValid()) |
| return m_type_system->IsDefined(m_type); |
| return true; |
| } |
| |
| bool CompilerType::IsPolymorphicClass() const { |
| if (IsValid()) { |
| return m_type_system->IsPolymorphicClass(m_type); |
| } |
| return false; |
| } |
| |
| bool CompilerType::IsPossibleDynamicType(CompilerType *dynamic_pointee_type, |
| bool check_cplusplus, |
| bool check_objc) const { |
| if (IsValid()) |
| return m_type_system->IsPossibleDynamicType(m_type, dynamic_pointee_type, |
| check_cplusplus, check_objc); |
| return false; |
| } |
| |
| bool CompilerType::IsScalarType() const { |
| if (!IsValid()) |
| return false; |
| |
| return m_type_system->IsScalarType(m_type); |
| } |
| |
| bool CompilerType::IsTypedefType() const { |
| if (!IsValid()) |
| return false; |
| return m_type_system->IsTypedefType(m_type); |
| } |
| |
| bool CompilerType::IsVoidType() const { |
| if (!IsValid()) |
| return false; |
| return m_type_system->IsVoidType(m_type); |
| } |
| |
| bool CompilerType::IsPointerToScalarType() const { |
| if (!IsValid()) |
| return false; |
| |
| return IsPointerType() && GetPointeeType().IsScalarType(); |
| } |
| |
| bool CompilerType::IsArrayOfScalarType() const { |
| CompilerType element_type; |
| if (IsArrayType(&element_type, nullptr, nullptr)) |
| return element_type.IsScalarType(); |
| return false; |
| } |
| |
| bool CompilerType::IsBeingDefined() const { |
| if (!IsValid()) |
| return false; |
| return m_type_system->IsBeingDefined(m_type); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Type Completion |
| //---------------------------------------------------------------------- |
| |
| bool CompilerType::GetCompleteType() const { |
| if (!IsValid()) |
| return false; |
| return m_type_system->GetCompleteType(m_type); |
| } |
| |
| //---------------------------------------------------------------------- |
| // AST related queries |
| //---------------------------------------------------------------------- |
| size_t CompilerType::GetPointerByteSize() const { |
| if (m_type_system) |
| return m_type_system->GetPointerByteSize(); |
| return 0; |
| } |
| |
| ConstString CompilerType::GetConstQualifiedTypeName() const { |
| return GetConstTypeName(); |
| } |
| |
| ConstString CompilerType::GetConstTypeName() const { |
| if (IsValid()) { |
| ConstString type_name(GetTypeName()); |
| if (type_name) |
| return type_name; |
| } |
| return ConstString("<invalid>"); |
| } |
| |
| ConstString CompilerType::GetTypeName() const { |
| if (IsValid()) { |
| return m_type_system->GetTypeName(m_type); |
| } |
| return ConstString("<invalid>"); |
| } |
| |
| ConstString CompilerType::GetDisplayTypeName() const { return GetTypeName(); } |
| |
| uint32_t CompilerType::GetTypeInfo( |
| CompilerType *pointee_or_element_compiler_type) const { |
| if (!IsValid()) |
| return 0; |
| |
| return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type); |
| } |
| |
| lldb::LanguageType CompilerType::GetMinimumLanguage() { |
| if (!IsValid()) |
| return lldb::eLanguageTypeC; |
| |
| return m_type_system->GetMinimumLanguage(m_type); |
| } |
| |
| lldb::TypeClass CompilerType::GetTypeClass() const { |
| if (!IsValid()) |
| return lldb::eTypeClassInvalid; |
| |
| return m_type_system->GetTypeClass(m_type); |
| } |
| |
| void CompilerType::SetCompilerType(TypeSystem *type_system, |
| lldb::opaque_compiler_type_t type) { |
| m_type_system = type_system; |
| m_type = type; |
| } |
| |
| void CompilerType::SetCompilerType(clang::ASTContext *ast, |
| clang::QualType qual_type) { |
| m_type_system = ClangASTContext::GetASTContext(ast); |
| m_type = qual_type.getAsOpaquePtr(); |
| } |
| |
| unsigned CompilerType::GetTypeQualifiers() const { |
| if (IsValid()) |
| return m_type_system->GetTypeQualifiers(m_type); |
| return 0; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Creating related types |
| //---------------------------------------------------------------------- |
| |
| CompilerType CompilerType::GetArrayElementType(uint64_t *stride) const { |
| if (IsValid()) { |
| return m_type_system->GetArrayElementType(m_type, stride); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetArrayType(uint64_t size) const { |
| if (IsValid()) { |
| return m_type_system->GetArrayType(m_type, size); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetCanonicalType() const { |
| if (IsValid()) |
| return m_type_system->GetCanonicalType(m_type); |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetFullyUnqualifiedType() const { |
| if (IsValid()) |
| return m_type_system->GetFullyUnqualifiedType(m_type); |
| return CompilerType(); |
| } |
| |
| int CompilerType::GetFunctionArgumentCount() const { |
| if (IsValid()) { |
| return m_type_system->GetFunctionArgumentCount(m_type); |
| } |
| return -1; |
| } |
| |
| CompilerType CompilerType::GetFunctionArgumentTypeAtIndex(size_t idx) const { |
| if (IsValid()) { |
| return m_type_system->GetFunctionArgumentTypeAtIndex(m_type, idx); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetFunctionReturnType() const { |
| if (IsValid()) { |
| return m_type_system->GetFunctionReturnType(m_type); |
| } |
| return CompilerType(); |
| } |
| |
| size_t CompilerType::GetNumMemberFunctions() const { |
| if (IsValid()) { |
| return m_type_system->GetNumMemberFunctions(m_type); |
| } |
| return 0; |
| } |
| |
| TypeMemberFunctionImpl CompilerType::GetMemberFunctionAtIndex(size_t idx) { |
| if (IsValid()) { |
| return m_type_system->GetMemberFunctionAtIndex(m_type, idx); |
| } |
| return TypeMemberFunctionImpl(); |
| } |
| |
| CompilerType CompilerType::GetNonReferenceType() const { |
| if (IsValid()) |
| return m_type_system->GetNonReferenceType(m_type); |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetPointeeType() const { |
| if (IsValid()) { |
| return m_type_system->GetPointeeType(m_type); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetPointerType() const { |
| if (IsValid()) { |
| return m_type_system->GetPointerType(m_type); |
| } |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetLValueReferenceType() const { |
| if (IsValid()) |
| return m_type_system->GetLValueReferenceType(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetRValueReferenceType() const { |
| if (IsValid()) |
| return m_type_system->GetRValueReferenceType(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::AddConstModifier() const { |
| if (IsValid()) |
| return m_type_system->AddConstModifier(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::AddVolatileModifier() const { |
| if (IsValid()) |
| return m_type_system->AddVolatileModifier(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::AddRestrictModifier() const { |
| if (IsValid()) |
| return m_type_system->AddRestrictModifier(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType |
| CompilerType::CreateTypedef(const char *name, |
| const CompilerDeclContext &decl_ctx) const { |
| if (IsValid()) |
| return m_type_system->CreateTypedef(m_type, name, decl_ctx); |
| else |
| return CompilerType(); |
| } |
| |
| CompilerType CompilerType::GetTypedefedType() const { |
| if (IsValid()) |
| return m_type_system->GetTypedefedType(m_type); |
| else |
| return CompilerType(); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Create related types using the current type's AST |
| //---------------------------------------------------------------------- |
| |
| CompilerType |
| CompilerType::GetBasicTypeFromAST(lldb::BasicType basic_type) const { |
| if (IsValid()) |
| return m_type_system->GetBasicTypeFromAST(basic_type); |
| return CompilerType(); |
| } |
| //---------------------------------------------------------------------- |
| // Exploring the type |
| //---------------------------------------------------------------------- |
| |
| uint64_t CompilerType::GetBitSize(ExecutionContextScope *exe_scope) const { |
| if (IsValid()) { |
| return m_type_system->GetBitSize(m_type, exe_scope); |
| } |
| return 0; |
| } |
| |
| uint64_t CompilerType::GetByteSize(ExecutionContextScope *exe_scope) const { |
| return (GetBitSize(exe_scope) + 7) / 8; |
| } |
| |
| size_t CompilerType::GetTypeBitAlign() const { |
| if (IsValid()) |
| return m_type_system->GetTypeBitAlign(m_type); |
| return 0; |
| } |
| |
| lldb::Encoding CompilerType::GetEncoding(uint64_t &count) const { |
| if (!IsValid()) |
| return lldb::eEncodingInvalid; |
| |
| return m_type_system->GetEncoding(m_type, count); |
| } |
| |
| lldb::Format CompilerType::GetFormat() const { |
| if (!IsValid()) |
| return lldb::eFormatDefault; |
| |
| return m_type_system->GetFormat(m_type); |
| } |
| |
| uint32_t CompilerType::GetNumChildren(bool omit_empty_base_classes) const { |
| if (!IsValid()) |
| return 0; |
| return m_type_system->GetNumChildren(m_type, omit_empty_base_classes); |
| } |
| |
| lldb::BasicType CompilerType::GetBasicTypeEnumeration() const { |
| if (IsValid()) |
| return m_type_system->GetBasicTypeEnumeration(m_type); |
| return eBasicTypeInvalid; |
| } |
| |
| void CompilerType::ForEachEnumerator( |
| std::function<bool(const CompilerType &integer_type, |
| const ConstString &name, |
| const llvm::APSInt &value)> const &callback) const { |
| if (IsValid()) |
| return m_type_system->ForEachEnumerator(m_type, callback); |
| } |
| |
| uint32_t CompilerType::GetNumFields() const { |
| if (!IsValid()) |
| return 0; |
| return m_type_system->GetNumFields(m_type); |
| } |
| |
| CompilerType CompilerType::GetFieldAtIndex(size_t idx, std::string &name, |
| uint64_t *bit_offset_ptr, |
| uint32_t *bitfield_bit_size_ptr, |
| bool *is_bitfield_ptr) const { |
| if (!IsValid()) |
| return CompilerType(); |
| return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr, |
| bitfield_bit_size_ptr, is_bitfield_ptr); |
| } |
| |
| uint32_t CompilerType::GetNumDirectBaseClasses() const { |
| if (IsValid()) |
| return m_type_system->GetNumDirectBaseClasses(m_type); |
| return 0; |
| } |
| |
| uint32_t CompilerType::GetNumVirtualBaseClasses() const { |
| if (IsValid()) |
| return m_type_system->GetNumVirtualBaseClasses(m_type); |
| return 0; |
| } |
| |
| CompilerType |
| CompilerType::GetDirectBaseClassAtIndex(size_t idx, |
| uint32_t *bit_offset_ptr) const { |
| if (IsValid()) |
| return m_type_system->GetDirectBaseClassAtIndex(m_type, idx, |
| bit_offset_ptr); |
| return CompilerType(); |
| } |
| |
| CompilerType |
| CompilerType::GetVirtualBaseClassAtIndex(size_t idx, |
| uint32_t *bit_offset_ptr) const { |
| if (IsValid()) |
| return m_type_system->GetVirtualBaseClassAtIndex(m_type, idx, |
| bit_offset_ptr); |
| return CompilerType(); |
| } |
| |
| uint32_t CompilerType::GetIndexOfFieldWithName( |
| const char *name, CompilerType *field_compiler_type_ptr, |
| uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, |
| bool *is_bitfield_ptr) const { |
| unsigned count = GetNumFields(); |
| std::string field_name; |
| for (unsigned index = 0; index < count; index++) { |
| CompilerType field_compiler_type( |
| GetFieldAtIndex(index, field_name, bit_offset_ptr, |
| bitfield_bit_size_ptr, is_bitfield_ptr)); |
| if (strcmp(field_name.c_str(), name) == 0) { |
| if (field_compiler_type_ptr) |
| *field_compiler_type_ptr = field_compiler_type; |
| return index; |
| } |
| } |
| return UINT32_MAX; |
| } |
| |
| CompilerType 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 { |
| if (!IsValid()) |
| return CompilerType(); |
| return m_type_system->GetChildCompilerTypeAtIndex( |
| m_type, exe_ctx, idx, transparent_pointers, omit_empty_base_classes, |
| ignore_array_bounds, child_name, child_byte_size, child_byte_offset, |
| child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, |
| child_is_deref_of_parent, valobj, language_flags); |
| } |
| |
| // Look for a child member (doesn't include base classes, but it does include |
| // their members) in the type hierarchy. Returns an index path into |
| // "clang_type" on how to reach the appropriate member. |
| // |
| // class A |
| // { |
| // public: |
| // int m_a; |
| // int m_b; |
| // }; |
| // |
| // class B |
| // { |
| // }; |
| // |
| // class C : |
| // public B, |
| // public A |
| // { |
| // }; |
| // |
| // If we have a clang type that describes "class C", and we wanted to looked |
| // "m_b" in it: |
| // |
| // With omit_empty_base_classes == false we would get an integer array back |
| // with: { 1, 1 } The first index 1 is the child index for "class A" within |
| // class C The second index 1 is the child index for "m_b" within class A |
| // |
| // With omit_empty_base_classes == true we would get an integer array back |
| // with: { 0, 1 } The first index 0 is the child index for "class A" within |
| // class C (since class B doesn't have any members it doesn't count) The second |
| // index 1 is the child index for "m_b" within class A |
| |
| size_t CompilerType::GetIndexOfChildMemberWithName( |
| const char *name, bool omit_empty_base_classes, |
| std::vector<uint32_t> &child_indexes) const { |
| if (IsValid() && name && name[0]) { |
| return m_type_system->GetIndexOfChildMemberWithName( |
| m_type, name, omit_empty_base_classes, child_indexes); |
| } |
| return 0; |
| } |
| |
| size_t CompilerType::GetNumTemplateArguments() const { |
| if (IsValid()) { |
| return m_type_system->GetNumTemplateArguments(m_type); |
| } |
| return 0; |
| } |
| |
| TemplateArgumentKind CompilerType::GetTemplateArgumentKind(size_t idx) const { |
| if (IsValid()) |
| return m_type_system->GetTemplateArgumentKind(m_type, idx); |
| return eTemplateArgumentKindNull; |
| } |
| |
| CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const { |
| if (IsValid()) { |
| return m_type_system->GetTypeTemplateArgument(m_type, idx); |
| } |
| return CompilerType(); |
| } |
| |
| llvm::Optional<CompilerType::IntegralTemplateArgument> |
| CompilerType::GetIntegralTemplateArgument(size_t idx) const { |
| if (IsValid()) |
| return m_type_system->GetIntegralTemplateArgument(m_type, idx); |
| return llvm::None; |
| } |
| |
| CompilerType CompilerType::GetTypeForFormatters() const { |
| if (IsValid()) |
| return m_type_system->GetTypeForFormatters(m_type); |
| return CompilerType(); |
| } |
| |
| LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const { |
| if (IsValid()) |
| return m_type_system->ShouldPrintAsOneLiner(m_type, valobj); |
| return eLazyBoolCalculate; |
| } |
| |
| bool CompilerType::IsMeaninglessWithoutDynamicResolution() const { |
| if (IsValid()) |
| return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type); |
| return false; |
| } |
| |
| // Get the index of the child of "clang_type" whose name matches. This function |
| // doesn't descend into the children, but only looks one level deep and name |
| // matches can include base class names. |
| |
| uint32_t |
| CompilerType::GetIndexOfChildWithName(const char *name, |
| bool omit_empty_base_classes) const { |
| if (IsValid() && name && name[0]) { |
| return m_type_system->GetIndexOfChildWithName(m_type, name, |
| omit_empty_base_classes); |
| } |
| return UINT32_MAX; |
| } |
| |
| size_t CompilerType::ConvertStringToFloatValue(const char *s, uint8_t *dst, |
| size_t dst_size) const { |
| if (IsValid()) |
| return m_type_system->ConvertStringToFloatValue(m_type, s, dst, dst_size); |
| return 0; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Dumping types |
| //---------------------------------------------------------------------- |
| #define DEPTH_INCREMENT 2 |
| |
| void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s, |
| lldb::Format format, const DataExtractor &data, |
| lldb::offset_t data_byte_offset, |
| size_t data_byte_size, uint32_t bitfield_bit_size, |
| uint32_t bitfield_bit_offset, bool show_types, |
| bool show_summary, bool verbose, uint32_t depth) { |
| if (!IsValid()) |
| return; |
| m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset, |
| data_byte_size, bitfield_bit_size, |
| bitfield_bit_offset, show_types, show_summary, |
| verbose, depth); |
| } |
| |
| bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format, |
| const DataExtractor &data, |
| lldb::offset_t byte_offset, size_t byte_size, |
| uint32_t bitfield_bit_size, |
| uint32_t bitfield_bit_offset, |
| ExecutionContextScope *exe_scope) { |
| if (!IsValid()) |
| return false; |
| return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset, |
| byte_size, bitfield_bit_size, |
| bitfield_bit_offset, exe_scope); |
| } |
| |
| void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s, |
| const DataExtractor &data, |
| lldb::offset_t data_byte_offset, |
| size_t data_byte_size) { |
| if (IsValid()) |
| m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset, |
| data_byte_size); |
| } |
| |
| void CompilerType::DumpTypeDescription() const { |
| if (IsValid()) |
| m_type_system->DumpTypeDescription(m_type); |
| } |
| |
| void CompilerType::DumpTypeDescription(Stream *s) const { |
| if (IsValid()) { |
| m_type_system->DumpTypeDescription(m_type, s); |
| } |
| } |
| |
| bool CompilerType::GetValueAsScalar(const lldb_private::DataExtractor &data, |
| lldb::offset_t data_byte_offset, |
| size_t data_byte_size, |
| Scalar &value) const { |
| if (!IsValid()) |
| return false; |
| |
| if (IsAggregateType()) { |
| return false; // Aggregate types don't have scalar values |
| } else { |
| uint64_t count = 0; |
| lldb::Encoding encoding = GetEncoding(count); |
| |
| if (encoding == lldb::eEncodingInvalid || count != 1) |
| return false; |
| |
| const uint64_t byte_size = GetByteSize(nullptr); |
| lldb::offset_t offset = data_byte_offset; |
| switch (encoding) { |
| case lldb::eEncodingInvalid: |
| break; |
| case lldb::eEncodingVector: |
| break; |
| case lldb::eEncodingUint: |
| if (byte_size <= sizeof(unsigned long long)) { |
| uint64_t uval64 = data.GetMaxU64(&offset, byte_size); |
| if (byte_size <= sizeof(unsigned int)) { |
| value = (unsigned int)uval64; |
| return true; |
| } else if (byte_size <= sizeof(unsigned long)) { |
| value = (unsigned long)uval64; |
| return true; |
| } else if (byte_size <= sizeof(unsigned long long)) { |
| value = (unsigned long long)uval64; |
| return true; |
| } else |
| value.Clear(); |
| } |
| break; |
| |
| case lldb::eEncodingSint: |
| if (byte_size <= sizeof(long long)) { |
| int64_t sval64 = data.GetMaxS64(&offset, byte_size); |
| if (byte_size <= sizeof(int)) { |
| value = (int)sval64; |
| return true; |
| } else if (byte_size <= sizeof(long)) { |
| value = (long)sval64; |
| return true; |
| } else if (byte_size <= sizeof(long long)) { |
| value = (long long)sval64; |
| return true; |
| } else |
| value.Clear(); |
| } |
| break; |
| |
| case lldb::eEncodingIEEE754: |
| if (byte_size <= sizeof(long double)) { |
| uint32_t u32; |
| uint64_t u64; |
| if (byte_size == sizeof(float)) { |
| if (sizeof(float) == sizeof(uint32_t)) { |
| u32 = data.GetU32(&offset); |
| value = *((float *)&u32); |
| return true; |
| } else if (sizeof(float) == sizeof(uint64_t)) { |
| u64 = data.GetU64(&offset); |
| value = *((float *)&u64); |
| return true; |
| } |
| } else if (byte_size == sizeof(double)) { |
| if (sizeof(double) == sizeof(uint32_t)) { |
| u32 = data.GetU32(&offset); |
| value = *((double *)&u32); |
| return true; |
| } else if (sizeof(double) == sizeof(uint64_t)) { |
| u64 = data.GetU64(&offset); |
| value = *((double *)&u64); |
| return true; |
| } |
| } else if (byte_size == sizeof(long double)) { |
| if (sizeof(long double) == sizeof(uint32_t)) { |
| u32 = data.GetU32(&offset); |
| value = *((long double *)&u32); |
| return true; |
| } else if (sizeof(long double) == sizeof(uint64_t)) { |
| u64 = data.GetU64(&offset); |
| value = *((long double *)&u64); |
| return true; |
| } |
| } |
| } |
| break; |
| } |
| } |
| return false; |
| } |
| |
| bool CompilerType::SetValueFromScalar(const Scalar &value, Stream &strm) { |
| if (!IsValid()) |
| return false; |
| |
| // Aggregate types don't have scalar values |
| if (!IsAggregateType()) { |
| strm.GetFlags().Set(Stream::eBinary); |
| uint64_t count = 0; |
| lldb::Encoding encoding = GetEncoding(count); |
| |
| if (encoding == lldb::eEncodingInvalid || count != 1) |
| return false; |
| |
| const uint64_t bit_width = GetBitSize(nullptr); |
| // This function doesn't currently handle non-byte aligned assignments |
| if ((bit_width % 8) != 0) |
| return false; |
| |
| const uint64_t byte_size = (bit_width + 7) / 8; |
| switch (encoding) { |
| case lldb::eEncodingInvalid: |
| break; |
| case lldb::eEncodingVector: |
| break; |
| case lldb::eEncodingUint: |
| switch (byte_size) { |
| case 1: |
| strm.PutHex8(value.UInt()); |
| return true; |
| case 2: |
| strm.PutHex16(value.UInt()); |
| return true; |
| case 4: |
| strm.PutHex32(value.UInt()); |
| return true; |
| case 8: |
| strm.PutHex64(value.ULongLong()); |
| return true; |
| default: |
| break; |
| } |
| break; |
| |
| case lldb::eEncodingSint: |
| switch (byte_size) { |
| case 1: |
| strm.PutHex8(value.SInt()); |
| return true; |
| case 2: |
| strm.PutHex16(value.SInt()); |
| return true; |
| case 4: |
| strm.PutHex32(value.SInt()); |
| return true; |
| case 8: |
| strm.PutHex64(value.SLongLong()); |
| return true; |
| default: |
| break; |
| } |
| break; |
| |
| case lldb::eEncodingIEEE754: |
| if (byte_size <= sizeof(long double)) { |
| if (byte_size == sizeof(float)) { |
| strm.PutFloat(value.Float()); |
| return true; |
| } else if (byte_size == sizeof(double)) { |
| strm.PutDouble(value.Double()); |
| return true; |
| } else if (byte_size == sizeof(long double)) { |
| strm.PutDouble(value.LongDouble()); |
| return true; |
| } |
| } |
| break; |
| } |
| } |
| return false; |
| } |
| |
| bool CompilerType::ReadFromMemory(lldb_private::ExecutionContext *exe_ctx, |
| lldb::addr_t addr, AddressType address_type, |
| lldb_private::DataExtractor &data) { |
| if (!IsValid()) |
| return false; |
| |
| // Can't convert a file address to anything valid without more context (which |
| // Module it came from) |
| if (address_type == eAddressTypeFile) |
| return false; |
| |
| if (!GetCompleteType()) |
| return false; |
| |
| const uint64_t byte_size = |
| GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); |
| if (data.GetByteSize() < byte_size) { |
| lldb::DataBufferSP data_sp(new DataBufferHeap(byte_size, '\0')); |
| data.SetData(data_sp); |
| } |
| |
| uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, byte_size)); |
| if (dst != nullptr) { |
| if (address_type == eAddressTypeHost) { |
| if (addr == 0) |
| return false; |
| // The address is an address in this process, so just copy it |
| memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size); |
| return true; |
| } else { |
| Process *process = nullptr; |
| if (exe_ctx) |
| process = exe_ctx->GetProcessPtr(); |
| if (process) { |
| Status error; |
| return process->ReadMemory(addr, dst, byte_size, error) == byte_size; |
| } |
| } |
| } |
| return false; |
| } |
| |
| bool CompilerType::WriteToMemory(lldb_private::ExecutionContext *exe_ctx, |
| lldb::addr_t addr, AddressType address_type, |
| StreamString &new_value) { |
| if (!IsValid()) |
| return false; |
| |
| // Can't convert a file address to anything valid without more context (which |
| // Module it came from) |
| if (address_type == eAddressTypeFile) |
| return false; |
| |
| if (!GetCompleteType()) |
| return false; |
| |
| const uint64_t byte_size = |
| GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); |
| |
| if (byte_size > 0) { |
| if (address_type == eAddressTypeHost) { |
| // The address is an address in this process, so just copy it |
| memcpy((void *)addr, new_value.GetData(), byte_size); |
| return true; |
| } else { |
| Process *process = nullptr; |
| if (exe_ctx) |
| process = exe_ctx->GetProcessPtr(); |
| if (process) { |
| Status error; |
| return process->WriteMemory(addr, new_value.GetData(), byte_size, |
| error) == byte_size; |
| } |
| } |
| } |
| return false; |
| } |
| |
| // clang::CXXRecordDecl * |
| // CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t |
| // opaque_compiler_qual_type) |
| //{ |
| // if (opaque_compiler_qual_type) |
| // return |
| // clang::QualType::getFromOpaquePtr(opaque_compiler_qual_type)->getAsCXXRecordDecl(); |
| // return NULL; |
| //} |
| |
| bool lldb_private::operator==(const lldb_private::CompilerType &lhs, |
| const lldb_private::CompilerType &rhs) { |
| return lhs.GetTypeSystem() == rhs.GetTypeSystem() && |
| lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType(); |
| } |
| |
| bool lldb_private::operator!=(const lldb_private::CompilerType &lhs, |
| const lldb_private::CompilerType &rhs) { |
| return lhs.GetTypeSystem() != rhs.GetTypeSystem() || |
| lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType(); |
| } |
