diff options
Diffstat (limited to 'lldb/source/Symbol/ClangASTType.cpp')
| -rw-r--r-- | lldb/source/Symbol/ClangASTType.cpp | 1771 |
1 files changed, 0 insertions, 1771 deletions
diff --git a/lldb/source/Symbol/ClangASTType.cpp b/lldb/source/Symbol/ClangASTType.cpp deleted file mode 100644 index 0241c3841a66..000000000000 --- a/lldb/source/Symbol/ClangASTType.cpp +++ /dev/null @@ -1,1771 +0,0 @@ -//===-- ClangASTType.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/ClangASTType.h" - -#include "clang/AST/ASTConsumer.h" -#include "clang/AST/ASTContext.h" -#include "clang/AST/Decl.h" -#include "clang/AST/DeclCXX.h" -#include "clang/AST/DeclObjC.h" -#include "clang/AST/DeclGroup.h" -#include "clang/AST/RecordLayout.h" -#include "clang/AST/Type.h" - -#include "clang/Basic/Builtins.h" -#include "clang/Basic/IdentifierTable.h" -#include "clang/Basic/LangOptions.h" -#include "clang/Basic/SourceManager.h" -#include "clang/Basic/TargetInfo.h" - -#include "llvm/Support/FormattedStream.h" -#include "llvm/Support/raw_ostream.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/StreamString.h" -#include "lldb/Symbol/ClangASTContext.h" -#include "lldb/Target/ExecutionContext.h" -#include "lldb/Target/Process.h" - -using namespace lldb; -using namespace lldb_private; - - -ClangASTType::~ClangASTType() -{ -} - -std::string -ClangASTType::GetTypeNameForQualType (clang::ASTContext *ast, clang::QualType qual_type) -{ - std::string type_name; - - clang::PrintingPolicy printing_policy (ast->getPrintingPolicy()); - printing_policy.SuppressTagKeyword = true; - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); - type_name = typedef_decl->getQualifiedNameAsString(printing_policy); - } - else - { - type_name = qual_type.getAsString(printing_policy); - } - return type_name; -} - -std::string -ClangASTType::GetTypeNameForOpaqueQualType (clang::ASTContext *ast, clang_type_t opaque_qual_type) -{ - return GetTypeNameForQualType (ast, clang::QualType::getFromOpaquePtr(opaque_qual_type)); -} - - -ConstString -ClangASTType::GetConstTypeName () -{ - // TODO: verify if we actually need to complete a type just to get its type name???? - if (!ClangASTContext::GetCompleteType (this->m_ast, this->m_type)) - return ConstString("<invalid>"); - return GetConstTypeName (m_ast, m_type); -} - -ConstString -ClangASTType::GetConstQualifiedTypeName () -{ - // TODO: verify if we actually need to complete a type just to get its fully qualified type name???? - if (!ClangASTContext::GetCompleteType (this->m_ast, this->m_type)) - return ConstString("<invalid>"); - return GetConstQualifiedTypeName (m_ast, m_type); -} - -ConstString -ClangASTType::GetConstQualifiedTypeName (clang::ASTContext *ast, clang_type_t clang_type) -{ - if (ast == NULL || clang_type == NULL) - return ConstString("<invalid>"); - - return ConstString (GetTypeNameForQualType (ast, clang::QualType::getFromOpaquePtr(clang_type)).c_str()); -} - - -ConstString -ClangASTType::GetConstTypeName (clang::ASTContext *ast, clang_type_t clang_type) -{ - if (!clang_type) - return ConstString("<invalid>"); - - std::string type_name (GetTypeNameForOpaqueQualType(ast, clang_type)); - ConstString const_type_name; - if (type_name.empty()) - const_type_name.SetCString ("<invalid>"); - else - const_type_name.SetCString(type_name.c_str()); - return const_type_name; -} - -clang_type_t -ClangASTType::GetPointeeType () -{ - return GetPointeeType (m_type); -} - -clang_type_t -ClangASTType::GetPointeeType (clang_type_t clang_type) -{ - if (clang_type) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - return qual_type.getTypePtr()->getPointeeType().getAsOpaquePtr(); - } - return NULL; -} - -lldb::clang_type_t -ClangASTType::GetArrayElementType (uint32_t& stride) -{ - return GetArrayElementType(m_ast, m_type, stride); -} - -lldb::clang_type_t -ClangASTType::GetArrayElementType (clang::ASTContext* ast, - lldb::clang_type_t opaque_clang_qual_type, - uint32_t& stride) -{ - if (opaque_clang_qual_type) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); - - lldb::clang_type_t ret_type = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified().getAsOpaquePtr(); - - // TODO: the real stride will be >= this value.. find the real one! - stride = GetTypeByteSize(ast, ret_type); - - return ret_type; - - } - return NULL; - -} - -lldb::clang_type_t -ClangASTType::GetPointerType () const -{ - return GetPointerType (m_ast, m_type); -} - -lldb::clang_type_t -ClangASTType::GetPointerType (clang::ASTContext *ast_context, - lldb::clang_type_t opaque_clang_qual_type) -{ - if (opaque_clang_qual_type) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); - - return ast_context->getPointerType(qual_type).getAsOpaquePtr(); - } - return NULL; -} - -lldb::Encoding -ClangASTType::GetEncoding (uint32_t &count) -{ - return GetEncoding(m_type, count); -} - - -lldb::LanguageType -ClangASTType::GetMinimumLanguage () -{ - return ClangASTType::GetMinimumLanguage (m_ast, - m_type); -} - -lldb::TypeClass -ClangASTType::GetTypeClass (clang::ASTContext *ast_context, lldb::clang_type_t clang_type) -{ - if (clang_type == NULL) - return lldb::eTypeClassInvalid; - - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: break; - case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction; - case clang::Type::FunctionProto: return lldb::eTypeClassFunction; - case clang::Type::IncompleteArray: return lldb::eTypeClassArray; - case clang::Type::VariableArray: return lldb::eTypeClassArray; - case clang::Type::ConstantArray: return lldb::eTypeClassArray; - case clang::Type::DependentSizedArray: return lldb::eTypeClassArray; - case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector; - case clang::Type::ExtVector: return lldb::eTypeClassVector; - case clang::Type::Vector: return lldb::eTypeClassVector; - case clang::Type::Builtin: return lldb::eTypeClassBuiltin; - case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer; - case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer; - case clang::Type::Pointer: return lldb::eTypeClassPointer; - case clang::Type::LValueReference: return lldb::eTypeClassReference; - case clang::Type::RValueReference: return lldb::eTypeClassReference; - case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer; - case clang::Type::Complex: - if (qual_type->isComplexType()) - return lldb::eTypeClassComplexFloat; - else - return lldb::eTypeClassComplexInteger; - case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject; - case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; - case clang::Type::Record: - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - if (record_decl->isUnion()) - return lldb::eTypeClassUnion; - else if (record_decl->isStruct()) - return lldb::eTypeClassStruct; - else - return lldb::eTypeClassClass; - } - break; - case clang::Type::Enum: return lldb::eTypeClassEnumeration; - case clang::Type::Typedef: return lldb::eTypeClassTypedef; - case clang::Type::UnresolvedUsing: break; - case clang::Type::Paren: break; - case clang::Type::Elaborated: break; - case clang::Type::Attributed: break; - case clang::Type::TemplateTypeParm: break; - case clang::Type::SubstTemplateTypeParm: break; - case clang::Type::SubstTemplateTypeParmPack:break; - case clang::Type::Auto: break; - case clang::Type::InjectedClassName: break; - case clang::Type::DependentName: break; - case clang::Type::DependentTemplateSpecialization: break; - case clang::Type::PackExpansion: break; - - case clang::Type::TypeOfExpr: break; - case clang::Type::TypeOf: break; - case clang::Type::Decltype: break; - case clang::Type::TemplateSpecialization: break; - case clang::Type::Atomic: break; - } - // We don't know hot to display this type... - return lldb::eTypeClassOther; - -} - - -lldb::LanguageType -ClangASTType::GetMinimumLanguage (clang::ASTContext *ctx, - lldb::clang_type_t clang_type) -{ - if (clang_type == NULL) - return lldb::eLanguageTypeC; - - // If the type is a reference, then resolve it to what it refers to first: - clang::QualType qual_type (clang::QualType::getFromOpaquePtr(clang_type).getNonReferenceType()); - if (qual_type->isAnyPointerType()) - { - if (qual_type->isObjCObjectPointerType()) - return lldb::eLanguageTypeObjC; - - clang::QualType pointee_type (qual_type->getPointeeType()); - if (pointee_type->getCXXRecordDeclForPointerType() != NULL) - return lldb::eLanguageTypeC_plus_plus; - if (pointee_type->isObjCObjectOrInterfaceType()) - return lldb::eLanguageTypeObjC; - if (pointee_type->isObjCClassType()) - return lldb::eLanguageTypeObjC; - if (pointee_type.getTypePtr() == ctx->ObjCBuiltinIdTy.getTypePtr()) - return lldb::eLanguageTypeObjC; - } - else - { - if (qual_type->isObjCObjectOrInterfaceType()) - return lldb::eLanguageTypeObjC; - if (qual_type->getAsCXXRecordDecl()) - return lldb::eLanguageTypeC_plus_plus; - switch (qual_type->getTypeClass()) - { - default: - break; - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: - case clang::BuiltinType::Void: - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: - break; - - case clang::BuiltinType::NullPtr: - return eLanguageTypeC_plus_plus; - - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - return eLanguageTypeObjC; - - case clang::BuiltinType::Dependent: - case clang::BuiltinType::Overload: - case clang::BuiltinType::BoundMember: - case clang::BuiltinType::UnknownAny: - break; - } - break; - case clang::Type::Typedef: - return GetMinimumLanguage(ctx, - llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - } - } - return lldb::eLanguageTypeC; -} - -lldb::Encoding -ClangASTType::GetEncoding (clang_type_t clang_type, uint32_t &count) -{ - count = 1; - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: - break; - - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - break; - - case clang::Type::ExtVector: - case clang::Type::Vector: - // TODO: Set this to more than one??? - break; - - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: assert(0 && "Unknown builtin type!"); - case clang::BuiltinType::Void: - break; - - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: return lldb::eEncodingSint; - - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: return lldb::eEncodingUint; - - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754; - - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCSel: return lldb::eEncodingUint; - - case clang::BuiltinType::NullPtr: return lldb::eEncodingUint; - } - break; - // All pointer types are represented as unsigned integer encodings. - // We may nee to add a eEncodingPointer if we ever need to know the - // difference - case clang::Type::ObjCObjectPointer: - case clang::Type::BlockPointer: - case clang::Type::Pointer: - case clang::Type::LValueReference: - case clang::Type::RValueReference: - case clang::Type::MemberPointer: return lldb::eEncodingUint; - case clang::Type::Complex: - { - lldb::Encoding encoding = lldb::eEncodingIEEE754; - if (qual_type->isComplexType()) - encoding = lldb::eEncodingIEEE754; - else - { - const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType(); - if (complex_type) - encoding = GetEncoding (complex_type->getElementType().getAsOpaquePtr(), count); - else - encoding = lldb::eEncodingSint; - } - count = 2; - return encoding; - } - - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eEncodingSint; - case clang::Type::Typedef: - return GetEncoding(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), count); - break; - - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::UnresolvedUsing: - case clang::Type::Paren: - case clang::Type::Elaborated: - case clang::Type::Attributed: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::Auto: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::TemplateSpecialization: - case clang::Type::Atomic: - break; - - } - count = 0; - return lldb::eEncodingInvalid; -} - -lldb::Format -ClangASTType::GetFormat () -{ - return GetFormat (m_type); -} - -lldb::Format -ClangASTType::GetFormat (clang_type_t clang_type) -{ - if (clang_type == NULL) - return lldb::eFormatDefault; - - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: - break; - - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - break; - - case clang::Type::ExtVector: - case clang::Type::Vector: - break; - - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - //default: assert(0 && "Unknown builtin type!"); - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::Void: - case clang::BuiltinType::BoundMember: - break; - - case clang::BuiltinType::Bool: return lldb::eFormatBoolean; - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: return lldb::eFormatChar; - case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; - case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; - case clang::BuiltinType::UShort: return lldb::eFormatUnsigned; - case clang::BuiltinType::Short: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt: return lldb::eFormatUnsigned; - case clang::BuiltinType::Int: return lldb::eFormatDecimal; - case clang::BuiltinType::ULong: return lldb::eFormatUnsigned; - case clang::BuiltinType::Long: return lldb::eFormatDecimal; - case clang::BuiltinType::ULongLong: return lldb::eFormatUnsigned; - case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt128: return lldb::eFormatUnsigned; - case clang::BuiltinType::Int128: return lldb::eFormatDecimal; - case clang::BuiltinType::Float: return lldb::eFormatFloat; - case clang::BuiltinType::Double: return lldb::eFormatFloat; - case clang::BuiltinType::LongDouble: return lldb::eFormatFloat; - case clang::BuiltinType::NullPtr: - case clang::BuiltinType::Overload: - case clang::BuiltinType::Dependent: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - case clang::BuiltinType::Half: - case clang::BuiltinType::ARCUnbridgedCast: - case clang::BuiltinType::PseudoObject: - return lldb::eFormatHex; - } - break; - case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; - case clang::Type::BlockPointer: return lldb::eFormatHex; - case clang::Type::Pointer: return lldb::eFormatHex; - case clang::Type::LValueReference: - case clang::Type::RValueReference: return lldb::eFormatHex; - case clang::Type::MemberPointer: break; - case clang::Type::Complex: - { - if (qual_type->isComplexType()) - return lldb::eFormatComplex; - else - return lldb::eFormatComplexInteger; - } - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eFormatEnum; - case clang::Type::Typedef: - return ClangASTType::GetFormat(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::UnresolvedUsing: - case clang::Type::Paren: - case clang::Type::Elaborated: - case clang::Type::Attributed: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::Auto: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::TemplateSpecialization: - case clang::Type::Atomic: - break; - } - // We don't know hot to display this type... - return lldb::eFormatBytes; -} - - -void -ClangASTType::DumpValue -( - ExecutionContext *exe_ctx, - Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_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 -) -{ - return DumpValue (m_ast, - 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); -} - -#define DEPTH_INCREMENT 2 -void -ClangASTType::DumpValue -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - ExecutionContext *exe_ctx, - Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_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 -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - switch (qual_type->getTypeClass()) - { - case clang::Type::Record: - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - uint32_t field_bit_offset = 0; - uint32_t field_byte_offset = 0; - const clang::ASTRecordLayout &record_layout = ast_context->getASTRecordLayout(record_decl); - uint32_t child_idx = 0; - - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - // We might have base classes to print out first - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - - // Skip empty base classes - if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - - if (base_class->isVirtual()) - field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; - else - field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; - field_byte_offset = field_bit_offset / 8; - assert (field_bit_offset % 8 == 0); - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - clang::QualType base_class_qual_type = base_class->getType(); - std::string base_class_type_name(base_class_qual_type.getAsString()); - - // Indent and print the base class type name - s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); - - std::pair<uint64_t, unsigned> base_class_type_info = ast_context->getTypeInfo(base_class_qual_type); - - // Dump the value of the member - DumpValue (ast_context, // The clang AST context for this type - base_class_qual_type.getAsOpaquePtr(),// The clang type we want to dump - exe_ctx, - s, // Stream to dump to - ClangASTType::GetFormat(base_class_qual_type.getAsOpaquePtr()), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - base_class_type_info.first / 8, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - - ++child_idx; - } - } - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comman (for member 2 and beyong) for - // the struct/union/class member. - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent - s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); - - clang::QualType field_type = field->getType(); - // Print the member type if requested - // Figure out the type byte size (field_type_info.first) and - // alignment (field_type_info.second) from the AST context. - std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(field_type); - assert(field_idx < record_layout.getFieldCount()); - // Figure out the field offset within the current struct/union/class type - field_bit_offset = record_layout.getFieldOffset (field_idx); - field_byte_offset = field_bit_offset / 8; - uint32_t field_bitfield_bit_size = 0; - uint32_t field_bitfield_bit_offset = 0; - if (ClangASTContext::FieldIsBitfield (ast_context, *field, field_bitfield_bit_size)) - field_bitfield_bit_offset = field_bit_offset % 8; - - if (show_types) - { - std::string field_type_name(field_type.getAsString()); - if (field_bitfield_bit_size > 0) - s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); - else - s->Printf("(%s) ", field_type_name.c_str()); - } - // Print the member name and equal sign - s->Printf("%s = ", field->getNameAsString().c_str()); - - - // Dump the value of the member - DumpValue (ast_context, // The clang AST context for this type - field_type.getAsOpaquePtr(), // The clang type we want to dump - exe_ctx, - s, // Stream to dump to - ClangASTType::GetFormat(field_type.getAsOpaquePtr()), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - field_type_info.first / 8, // Size of this type in bytes - field_bitfield_bit_size, // Bitfield bit size - field_bitfield_bit_offset, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (child_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - return; - - case clang::Type::Enum: - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enum_type->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - uint32_t offset = data_byte_offset; - const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal() == enum_value) - { - s->Printf("%s", enum_pos->getNameAsString().c_str()); - return; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - s->Printf("%lli", enum_value); - } - return; - - case clang::Type::ConstantArray: - { - const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr()); - bool is_array_of_characters = false; - clang::QualType element_qual_type = array->getElementType(); - - const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); - if (canonical_type) - is_array_of_characters = canonical_type->isCharType(); - - const uint64_t element_count = array->getSize().getLimitedValue(); - - std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(element_qual_type); - - uint32_t element_idx = 0; - uint32_t element_offset = 0; - uint64_t element_byte_size = field_type_info.first / 8; - uint32_t element_stride = element_byte_size; - - if (is_array_of_characters) - { - s->PutChar('"'); - data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - s->PutChar('"'); - return; - } - else - { - lldb::Format element_format = ClangASTType::GetFormat(element_qual_type.getAsOpaquePtr()); - - for (element_idx = 0; element_idx < element_count; ++element_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comman (for member 2 and beyong) for - // the struct/union/class member. - if (element_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent and print the index - s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); - - // Figure out the field offset within the current struct/union/class type - element_offset = element_idx * element_stride; - - // Dump the value of the member - DumpValue (ast_context, // The clang AST context for this type - element_qual_type.getAsOpaquePtr(), // The clang type we want to dump - exe_ctx, - s, // Stream to dump to - element_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset + element_offset,// Offset into "data" where to grab value from - element_byte_size, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (element_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - } - return; - - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(); - lldb::Format typedef_format = ClangASTType::GetFormat(typedef_qual_type.getAsOpaquePtr()); - std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.first / 8; - - return DumpValue (ast_context, // The clang AST context for this type - typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump - exe_ctx, - s, // Stream to dump to - typedef_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children - } - break; - - default: - // We are down the a scalar type that we just need to display. - data.Dump(s, data_byte_offset, format, data_byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset); - - if (show_summary) - DumpSummary (ast_context, clang_type, exe_ctx, s, data, data_byte_offset, data_byte_size); - break; - } -} - - - -bool -ClangASTType::DumpTypeValue (Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_t byte_offset, - size_t byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - ExecutionContextScope *exe_scope) -{ - return DumpTypeValue (m_ast, - m_type, - s, - format, - data, - byte_offset, - byte_size, - bitfield_bit_size, - bitfield_bit_offset, - exe_scope); -} - - -bool -ClangASTType::DumpTypeValue (clang::ASTContext *ast_context, - clang_type_t clang_type, - Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - uint32_t byte_offset, - size_t byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - ExecutionContextScope *exe_scope) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - if (ClangASTContext::IsAggregateType (clang_type)) - { - return 0; - } - else - { - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - - switch (type_class) - { - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(); - if (format == eFormatDefault) - format = ClangASTType::GetFormat(typedef_qual_type.getAsOpaquePtr()); - std::pair<uint64_t, unsigned> typedef_type_info = ast_context->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.first / 8; - - return ClangASTType::DumpTypeValue (ast_context, // The clang AST context for this type - typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump - s, - format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield - bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0 - exe_scope); - } - break; - - case clang::Type::Enum: - // If our format is enum or default, show the enumeration value as - // its enumeration string value, else just display it as requested. - if ((format == eFormatEnum || format == eFormatDefault) && ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enum_type->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - uint32_t offset = byte_offset; - const int64_t enum_value = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal() == enum_value) - { - s->PutCString (enum_pos->getNameAsString().c_str()); - return true; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - - s->Printf("%lli", enum_value); - return true; - } - // format was not enum, just fall through and dump the value as requested.... - - default: - // We are down the a scalar type that we just need to display. - { - uint32_t item_count = 1; - // A few formats, we might need to modify our size and count for depending - // on how we are trying to display the value... - switch (format) - { - default: - case eFormatBoolean: - case eFormatBinary: - case eFormatComplex: - case eFormatCString: // NULL terminated C strings - case eFormatDecimal: - case eFormatEnum: - case eFormatHex: - case eFormatFloat: - case eFormatOctal: - case eFormatOSType: - case eFormatUnsigned: - case eFormatPointer: - case eFormatVectorOfChar: - case eFormatVectorOfSInt8: - case eFormatVectorOfUInt8: - case eFormatVectorOfSInt16: - case eFormatVectorOfUInt16: - case eFormatVectorOfSInt32: - case eFormatVectorOfUInt32: - case eFormatVectorOfSInt64: - case eFormatVectorOfUInt64: - case eFormatVectorOfFloat32: - case eFormatVectorOfFloat64: - case eFormatVectorOfUInt128: - break; - - case eFormatChar: - case eFormatCharPrintable: - case eFormatCharArray: - case eFormatBytes: - case eFormatBytesWithASCII: - item_count = byte_size; - byte_size = 1; - break; - - case eFormatUnicode16: - item_count = byte_size / 2; - byte_size = 2; - break; - - case eFormatUnicode32: - item_count = byte_size / 4; - byte_size = 4; - break; - } - return data.Dump (s, - byte_offset, - format, - byte_size, - item_count, - UINT32_MAX, - LLDB_INVALID_ADDRESS, - bitfield_bit_size, - bitfield_bit_offset, - exe_scope); - } - break; - } - } - return 0; -} - - - -void -ClangASTType::DumpSummary -( - ExecutionContext *exe_ctx, - Stream *s, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size -) -{ - return DumpSummary (m_ast, - m_type, - exe_ctx, - s, - data, - data_byte_offset, - data_byte_size); -} - -void -ClangASTType::DumpSummary -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - ExecutionContext *exe_ctx, - Stream *s, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size -) -{ - uint32_t length = 0; - if (ClangASTContext::IsCStringType (clang_type, length)) - { - if (exe_ctx) - { - Process *process = exe_ctx->GetProcessPtr(); - if (process) - { - uint32_t offset = data_byte_offset; - lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); - std::vector<uint8_t> buf; - if (length > 0) - buf.resize (length); - else - buf.resize (256); - - lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4); - buf.back() = '\0'; - size_t bytes_read; - size_t total_cstr_len = 0; - Error error; - while ((bytes_read = process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0) - { - const size_t len = strlen((const char *)&buf.front()); - if (len == 0) - break; - if (total_cstr_len == 0) - s->PutCString (" \""); - cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - total_cstr_len += len; - if (len < buf.size()) - break; - pointer_addresss += total_cstr_len; - } - if (total_cstr_len > 0) - s->PutChar ('"'); - } - } - } -} - -uint32_t -ClangASTType::GetClangTypeBitWidth () -{ - return GetClangTypeBitWidth (m_ast, m_type); -} - -uint32_t -ClangASTType::GetClangTypeBitWidth (clang::ASTContext *ast_context, clang_type_t clang_type) -{ - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - return ast_context->getTypeSize (qual_type); - } - return 0; -} - -size_t -ClangASTType::GetTypeBitAlign () -{ - return GetTypeBitAlign (m_ast, m_type); -} - -size_t -ClangASTType::GetTypeBitAlign (clang::ASTContext *ast_context, clang_type_t clang_type) -{ - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - return ast_context->getTypeAlign(clang::QualType::getFromOpaquePtr(clang_type)); - return 0; -} - - -bool -ClangASTType::IsDefined() -{ - return ClangASTType::IsDefined (m_type); -} - -bool -ClangASTType::IsDefined (clang_type_t clang_type) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - return tag_decl->isCompleteDefinition(); - return false; - } - else - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - return class_interface_decl->getDefinition() != NULL; - return false; - } - } - return true; -} - -bool -ClangASTType::IsConst() -{ - return ClangASTType::IsConst (m_type); -} - -bool -ClangASTType::IsConst (lldb::clang_type_t clang_type) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - return qual_type.isConstQualified(); -} - -void -ClangASTType::DumpTypeDescription (Stream *s) -{ - return DumpTypeDescription (m_ast, m_type, s); -} - -// Dump the full description of a type. For classes this means all of the -// ivars and member functions, for structs/unions all of the members. -void -ClangASTType::DumpTypeDescription (clang::ASTContext *ast_context, clang_type_t clang_type, Stream *s) -{ - if (clang_type) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - llvm::SmallVector<char, 1024> buf; - llvm::raw_svector_ostream llvm_ostrm (buf); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - { - clang::PrintingPolicy policy = ast_context->getPrintingPolicy(); - policy.Dump = 1; - class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); - } - } - } - break; - - case clang::Type::Typedef: - { - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); - std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); - if (!clang_typedef_name.empty()) - { - s->PutCString ("typedef "); - s->PutCString (clang_typedef_name.c_str()); - } - } - } - break; - - case clang::Type::Record: - if (ClangASTContext::GetCompleteType (ast_context, clang_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - - if (cxx_record_decl) - cxx_record_decl->print(llvm_ostrm, ast_context->getPrintingPolicy(), s->GetIndentLevel()); - else - record_decl->print(llvm_ostrm, ast_context->getPrintingPolicy(), s->GetIndentLevel()); - } - break; - - default: - { - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - tag_decl->print(llvm_ostrm, 0); - } - else - { - std::string clang_type_name(qual_type.getAsString()); - if (!clang_type_name.empty()) - s->PutCString (clang_type_name.c_str()); - } - } - } - - llvm_ostrm.flush(); - if (buf.size() > 0) - { - s->Write (buf.data(), buf.size()); - } - } -} - -void -ClangASTType::DumpTypeCode (Stream *s) -{ - DumpTypeCode(m_type, s); -} - -void -ClangASTType::DumpTypeCode (void *type, - Stream *s) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(type)); - s->PutCString(qual_type.getAsString().c_str()); -} - -bool -ClangASTType::GetValueAsScalar -( - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size, - Scalar &value -) -{ - return GetValueAsScalar (m_ast, - m_type, - data, - data_byte_offset, - data_byte_size, - value); -} - -bool -ClangASTType::GetValueAsScalar -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - const lldb_private::DataExtractor &data, - uint32_t data_byte_offset, - size_t data_byte_size, - Scalar &value -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - if (ClangASTContext::IsAggregateType (clang_type)) - { - return false; // Aggregate types don't have scalar values - } - else - { - uint32_t count = 0; - lldb::Encoding encoding = GetEncoding (clang_type, count); - - if (encoding == lldb::eEncodingInvalid || count != 1) - return false; - - uint64_t bit_width = ast_context->getTypeSize(qual_type); - uint32_t byte_size = (bit_width + 7 ) / 8; - uint32_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 -ClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm) -{ - return SetValueFromScalar (m_ast, m_type, value, strm); -} - -bool -ClangASTType::SetValueFromScalar -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - const Scalar &value, - Stream &strm -) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - // Aggregate types don't have scalar values - if (!ClangASTContext::IsAggregateType (clang_type)) - { - strm.GetFlags().Set(Stream::eBinary); - uint32_t count = 0; - lldb::Encoding encoding = GetEncoding (clang_type, count); - - if (encoding == lldb::eEncodingInvalid || count != 1) - return false; - - uint64_t bit_width = ast_context->getTypeSize(qual_type); - // This function doesn't currently handle non-byte aligned assignments - if ((bit_width % 8) != 0) - return false; - - uint32_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 -ClangASTType::ReadFromMemory -( - lldb_private::ExecutionContext *exe_ctx, - lldb::addr_t addr, - AddressType address_type, - lldb_private::DataExtractor &data -) -{ - return ReadFromMemory (m_ast, - m_type, - exe_ctx, - addr, - address_type, - data); -} - -uint32_t -ClangASTType::GetTypeByteSize() const -{ - return GetTypeByteSize(m_ast, - m_type); -} - -uint32_t -ClangASTType::GetTypeByteSize( - clang::ASTContext *ast_context, - lldb::clang_type_t opaque_clang_qual_type) -{ - - if (ClangASTContext::GetCompleteType (ast_context, opaque_clang_qual_type)) - { - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)); - return (ast_context->getTypeSize (qual_type) + 7) / 8; - } - return 0; -} - - -bool -ClangASTType::ReadFromMemory -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - lldb_private::ExecutionContext *exe_ctx, - lldb::addr_t addr, - AddressType address_type, - lldb_private::DataExtractor &data -) -{ - if (address_type == eAddressTypeFile) - { - // Can't convert a file address to anything valid without more - // context (which Module it came from) - return false; - } - - if (!ClangASTContext::GetCompleteType(ast_context, clang_type)) - return false; - - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - - const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; - if (data.GetByteSize() < byte_size) - { - lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); - data.SetData(data_sp); - } - - uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); - if (dst != NULL) - { - if (address_type == eAddressTypeHost) - { - // The address is an address in this process, so just copy it - memcpy (dst, (uint8_t*)NULL + addr, byte_size); - return true; - } - else - { - Process *process = NULL; - if (exe_ctx) - process = exe_ctx->GetProcessPtr(); - if (process) - { - Error error; - return process->ReadMemory(addr, dst, byte_size, error) == byte_size; - } - } - } - return false; -} - -bool -ClangASTType::WriteToMemory -( - lldb_private::ExecutionContext *exe_ctx, - lldb::addr_t addr, - AddressType address_type, - StreamString &new_value -) -{ - return WriteToMemory (m_ast, - m_type, - exe_ctx, - addr, - address_type, - new_value); -} - -bool -ClangASTType::WriteToMemory -( - clang::ASTContext *ast_context, - clang_type_t clang_type, - lldb_private::ExecutionContext *exe_ctx, - lldb::addr_t addr, - AddressType address_type, - StreamString &new_value -) -{ - if (address_type == eAddressTypeFile) - { - // Can't convert a file address to anything valid without more - // context (which Module it came from) - return false; - } - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - const uint32_t byte_size = (ast_context->getTypeSize (qual_type) + 7) / 8; - - 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 = NULL; - 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; -} - - -lldb::clang_type_t -ClangASTType::RemoveFastQualifiers (lldb::clang_type_t clang_type) -{ - clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); - qual_type.getQualifiers().removeFastQualifiers(); - return qual_type.getAsOpaquePtr(); -} - - -bool -lldb_private::operator == (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) -{ - return lhs.GetASTContext() == rhs.GetASTContext() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType(); -} - - -bool -lldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) -{ - return lhs.GetASTContext() != rhs.GetASTContext() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType(); -} |