diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Symbol/CompilerType.cpp')
| -rw-r--r-- | contrib/llvm/tools/lldb/source/Symbol/CompilerType.cpp | 1320 |
1 files changed, 1320 insertions, 0 deletions
diff --git a/contrib/llvm/tools/lldb/source/Symbol/CompilerType.cpp b/contrib/llvm/tools/lldb/source/Symbol/CompilerType.cpp new file mode 100644 index 000000000000..000a949626c5 --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Symbol/CompilerType.cpp @@ -0,0 +1,1320 @@ +//===-- 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/ConstString.h" +#include "lldb/Core/DataBufferHeap.h" +#include "lldb/Core/DataExtractor.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Scalar.h" +#include "lldb/Core/Stream.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StreamString.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 <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::IsIntegerType (bool &is_signed) const +{ + if (IsValid()) + return m_type_system->IsIntegerType(m_type, is_signed); + return false; +} + +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::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; +} + +CompilerType +CompilerType::GetTemplateArgument (size_t idx, + lldb::TemplateArgumentKind &kind) const +{ + if (IsValid()) + { + return m_type_system->GetTemplateArgument(m_type, idx, kind); + } + return CompilerType(); +} + +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 lldb_private::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 lldb_private::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 lldb_private::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, (uint8_t*)nullptr + addr, byte_size); + return true; + } + else + { + Process *process = nullptr; + if (exe_ctx) + process = exe_ctx->GetProcessPtr(); + if (process) + { + Error 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) + { + Error 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(); +} + + + |