| //===-- Type.cpp ------------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // Other libraries and framework includes |
| #include "clang/AST/ASTConsumer.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclGroup.h" |
| #include "clang/AST/RecordLayout.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/DataExtractor.h" |
| #include "lldb/Core/DataBufferHeap.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/Scalar.h" |
| #include "lldb/Core/StreamString.h" |
| |
| #include "lldb/Symbol/ClangASTContext.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Symbol/SymbolContextScope.h" |
| #include "lldb/Symbol/SymbolFile.h" |
| #include "lldb/Symbol/Type.h" |
| #include "lldb/Symbol/TypeList.h" |
| |
| #include "lldb/Target/ExecutionContext.h" |
| #include "lldb/Target/Process.h" |
| |
| lldb_private::Type::Type |
| ( |
| lldb::user_id_t uid, |
| SymbolFile* symbol_file, |
| const ConstString &name, |
| uint64_t byte_size, |
| SymbolContextScope *context, |
| lldb::user_id_t encoding_uid, |
| EncodingUIDType encoding_uid_type, |
| const Declaration& decl, |
| void *clang_type |
| ) : |
| UserID (uid), |
| m_name (name), |
| m_byte_size (byte_size), |
| m_symbol_file (symbol_file), |
| m_context (context), |
| m_encoding_uid (encoding_uid), |
| m_encoding_uid_type (encoding_uid_type), |
| m_decl (decl), |
| m_clang_qual_type (clang_type) |
| { |
| } |
| |
| lldb_private::Type::Type () : |
| UserID (0), |
| m_name ("<INVALID TYPE>"), |
| m_byte_size (0), |
| m_symbol_file (NULL), |
| m_context (), |
| m_encoding_uid (0), |
| m_encoding_uid_type (eTypeInvalid), |
| m_decl (), |
| m_clang_qual_type (NULL) |
| { |
| } |
| |
| |
| const lldb_private::Type& |
| lldb_private::Type::operator= (const Type& rhs) |
| { |
| if (this != &rhs) |
| { |
| UserID::operator= (rhs); |
| m_name = rhs.m_name; |
| m_byte_size = rhs.m_byte_size; |
| m_symbol_file = rhs.m_symbol_file; |
| m_context = rhs.m_context; |
| m_encoding_uid = rhs.m_encoding_uid; |
| m_decl = rhs.m_decl; |
| m_clang_qual_type = rhs.m_clang_qual_type; |
| } |
| return *this; |
| } |
| |
| |
| void |
| lldb_private::Type::Dump (Stream *s, bool show_context) |
| { |
| s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); |
| s->Indent(); |
| *s << "Type" << (const UserID&)*this << ' '; |
| if (m_name) |
| *s << ", name = \"" << m_name << "\""; |
| |
| if (m_byte_size != 0) |
| s->Printf(", size = %zu", m_byte_size); |
| |
| if (show_context && m_context != NULL) |
| { |
| s->PutCString(", context = ( "); |
| m_context->DumpSymbolContext(s); |
| s->PutCString(" )"); |
| } |
| |
| m_decl.Dump(s); |
| |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(m_clang_qual_type)); |
| |
| if (qual_type.getTypePtr()) |
| { |
| *s << ", clang_type = "; |
| |
| clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr()); |
| clang::TagDecl *tag_decl = NULL; |
| if (tag_type) |
| tag_decl = tag_type->getDecl(); |
| |
| if (tag_decl) |
| { |
| s->EOL(); |
| s->EOL(); |
| tag_decl->print(llvm::fouts(), 0); |
| s->EOL(); |
| } |
| else |
| { |
| const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); |
| if (typedef_type) |
| { |
| const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); |
| std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); |
| if (!clang_typedef_name.empty()) |
| *s << " (" << clang_typedef_name.c_str() << ')'; |
| } |
| else |
| { |
| // We have a clang type, lets show it |
| TypeList *type_list = GetTypeList(); |
| if (type_list) |
| { |
| clang::ASTContext *ast_context = GetClangAST(); |
| if (ast_context) |
| { |
| std::string clang_type_name(qual_type.getAsString()); |
| if (!clang_type_name.empty()) |
| *s << " (" << clang_type_name.c_str() << ')'; |
| } |
| } |
| } |
| } |
| } |
| else if (m_encoding_uid != LLDB_INVALID_UID) |
| { |
| *s << ", type_uid = " << m_encoding_uid; |
| switch (m_encoding_uid_type) |
| { |
| case eIsTypeWithUID: s->PutCString(" (unresolved type)"); break; |
| case eIsConstTypeWithUID: s->PutCString(" (unresolved const type)"); break; |
| case eIsRestrictTypeWithUID: s->PutCString(" (unresolved restrict type)"); break; |
| case eIsVolatileTypeWithUID: s->PutCString(" (unresolved volatile type)"); break; |
| case eTypedefToTypeWithUID: s->PutCString(" (unresolved typedef)"); break; |
| case ePointerToTypeWithUID: s->PutCString(" (unresolved pointer)"); break; |
| case eLValueReferenceToTypeWithUID: s->PutCString(" (unresolved L value reference)"); break; |
| case eRValueReferenceToTypeWithUID: s->PutCString(" (unresolved R value reference)"); break; |
| } |
| } |
| |
| // |
| // if (m_access) |
| // s->Printf(", access = %u", m_access); |
| s->EOL(); |
| } |
| |
| const lldb_private::ConstString & |
| lldb_private::Type::GetName() |
| { |
| if (!(m_name)) |
| { |
| if (ResolveClangType()) |
| { |
| std::string type_name = ClangASTContext::GetTypeName (m_clang_qual_type); |
| if (!type_name.empty()) |
| m_name.SetCString (type_name.c_str()); |
| } |
| } |
| return m_name; |
| } |
| |
| int |
| lldb_private::Type::DumpClangTypeName(Stream *s, void *clang_type) |
| { |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| std::string type_name; |
| const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); |
| if (typedef_type) |
| { |
| const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); |
| type_name = typedef_decl->getQualifiedNameAsString(); |
| } |
| else |
| { |
| type_name = qual_type.getAsString(); |
| } |
| if (!type_name.empty()) |
| return s->Printf("(%s) ", type_name.c_str()); |
| return 0; |
| } |
| |
| lldb_private::ConstString |
| lldb_private::Type::GetClangTypeName (void *clang_type) |
| { |
| ConstString clang_type_name; |
| if (clang_type) |
| { |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| |
| const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); |
| if (typedef_type) |
| { |
| const clang::TypedefDecl *typedef_decl = typedef_type->getDecl(); |
| std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); |
| if (!clang_typedef_name.empty()) |
| clang_type_name.SetCString (clang_typedef_name.c_str()); |
| } |
| else |
| { |
| std::string type_name(qual_type.getAsString()); |
| if (!type_name.empty()) |
| clang_type_name.SetCString (type_name.c_str()); |
| } |
| } |
| else |
| { |
| clang_type_name.SetCString ("<invalid>"); |
| } |
| |
| return clang_type_name; |
| } |
| |
| |
| |
| void |
| lldb_private::Type::DumpTypeName(Stream *s) |
| { |
| GetName().Dump(s, "<invalid-type-name>"); |
| } |
| |
| |
| void |
| lldb_private::Type::DumpValue |
| ( |
| lldb_private::ExecutionContext *exe_ctx, |
| lldb_private::Stream *s, |
| const lldb_private::DataExtractor &data, |
| uint32_t data_byte_offset, |
| bool show_types, |
| bool show_summary, |
| bool verbose, |
| lldb::Format format |
| ) |
| { |
| if (ResolveClangType()) |
| { |
| if (show_types) |
| { |
| s->PutChar('('); |
| if (verbose) |
| s->Printf("Type{0x%8.8x} ", GetID()); |
| DumpTypeName (s); |
| s->PutCString(") "); |
| } |
| |
| lldb_private::Type::DumpValue (exe_ctx, |
| GetClangAST (), |
| m_clang_qual_type, |
| s, |
| format == lldb::eFormatDefault ? GetFormat() : format, |
| data, |
| data_byte_offset, |
| GetByteSize(), |
| 0, // Bitfield bit size |
| 0, // Bitfield bit offset |
| show_types, |
| show_summary, |
| verbose, |
| 0); |
| } |
| } |
| |
| |
| void |
| lldb_private::Type::DumpSummary |
| ( |
| ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| void *clang_type, |
| Stream *s, |
| const lldb_private::DataExtractor &data, |
| uint32_t data_byte_offset, |
| size_t data_byte_size |
| ) |
| { |
| uint32_t length = 0; |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| if (ClangASTContext::IsCStringType (clang_type, length)) |
| { |
| |
| if (exe_ctx && exe_ctx->process) |
| { |
| uint32_t offset = data_byte_offset; |
| lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); |
| const size_t k_max_buf_size = length ? length : 256; |
| uint8_t buf[k_max_buf_size + 1]; |
| lldb_private::DataExtractor data(buf, k_max_buf_size, exe_ctx->process->GetByteOrder(), 4); |
| buf[k_max_buf_size] = '\0'; |
| size_t bytes_read; |
| size_t total_cstr_len = 0; |
| Error error; |
| while ((bytes_read = exe_ctx->process->ReadMemory (pointer_addresss, buf, k_max_buf_size, error)) > 0) |
| { |
| const size_t len = strlen((const char *)buf); |
| if (len == 0) |
| break; |
| if (total_cstr_len == 0) |
| s->PutCString (" \""); |
| data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); |
| total_cstr_len += len; |
| if (len < k_max_buf_size) |
| break; |
| pointer_addresss += total_cstr_len; |
| } |
| if (total_cstr_len > 0) |
| s->PutChar ('"'); |
| } |
| } |
| } |
| |
| #define DEPTH_INCREMENT 2 |
| void |
| lldb_private::Type::DumpValue |
| ( |
| ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| void *clang_type, |
| 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: |
| { |
| const clang::RecordType *record_type = 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 = 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 = 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); |
| else |
| field_bit_offset = record_layout.getBaseClassOffset(base_class_decl); |
| 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 |
| Type::DumpValue ( |
| exe_ctx, |
| ast_context, // The clang AST context for this type |
| base_class_qual_type.getAsOpaquePtr(),// The clang type we want to dump |
| s, // Stream to dump to |
| Type::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; |
| } |
| } |
| const unsigned num_fields = record_layout.getFieldCount(); |
| |
| 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 < num_fields); |
| // 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 |
| Type::DumpValue ( |
| exe_ctx, |
| ast_context, // The clang AST context for this type |
| field_type.getAsOpaquePtr(), // The clang type we want to dump |
| s, // Stream to dump to |
| Type::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: |
| { |
| const clang::EnumType *enum_type = 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->getNameAsCString()); |
| 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 = cast<clang::ConstantArrayType>(qual_type.getTypePtr()); |
| bool is_array_of_characters = false; |
| clang::QualType element_qual_type = array->getElementType(); |
| |
| 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 = Type::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 |
| Type::DumpValue ( |
| exe_ctx, |
| ast_context, // The clang AST context for this type |
| element_qual_type.getAsOpaquePtr(), // The clang type we want to dump |
| 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 = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); |
| lldb::Format typedef_format = lldb_private::Type::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 Type::DumpValue( |
| exe_ctx, |
| ast_context, // The clang AST context for this type |
| typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump |
| 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) |
| Type::DumpSummary (exe_ctx, ast_context, clang_type, s, data, data_byte_offset, data_byte_size); |
| break; |
| } |
| } |
| |
| bool |
| lldb_private::Type::DumpTypeValue |
| ( |
| Stream *s, |
| clang::ASTContext *ast_context, |
| void *clang_type, |
| 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 |
| ) |
| { |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| if (ClangASTContext::IsAggregateType (clang_type)) |
| { |
| return 0; |
| } |
| else |
| { |
| switch (qual_type->getTypeClass()) |
| { |
| case clang::Type::Enum: |
| { |
| const clang::EnumType *enum_type = 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->getNameAsCString()); |
| 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; |
| } |
| break; |
| |
| case clang::Type::Typedef: |
| { |
| clang::QualType typedef_qual_type = cast<clang::TypedefType>(qual_type)->LookThroughTypedefs(); |
| lldb::Format typedef_format = Type::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 Type::DumpTypeValue( |
| s, |
| ast_context, // The clang AST context for this type |
| typedef_qual_type.getAsOpaquePtr(), // The clang type we want to dump |
| typedef_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 |
| } |
| break; |
| |
| default: |
| // We are down the a scalar type that we just need to display. |
| return data.Dump(s, |
| byte_offset, |
| format, |
| byte_size, |
| 1, |
| UINT32_MAX, |
| LLDB_INVALID_ADDRESS, |
| bitfield_bit_size, |
| bitfield_bit_offset); |
| break; |
| } |
| } |
| return 0; |
| } |
| |
| bool |
| lldb_private::Type::GetValueAsScalar |
| ( |
| clang::ASTContext *ast_context, |
| void *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 = Type::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::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 = (int64_t)data.GetMaxU64 (&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 |
| lldb_private::Type::SetValueFromScalar |
| ( |
| clang::ASTContext *ast_context, |
| void *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 = Type::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::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; |
| } |
| |
| |
| uint64_t |
| lldb_private::Type::GetByteSize() |
| { |
| if (m_byte_size == 0) |
| { |
| switch (m_encoding_uid_type) |
| { |
| case eIsTypeWithUID: |
| case eIsConstTypeWithUID: |
| case eIsRestrictTypeWithUID: |
| case eIsVolatileTypeWithUID: |
| case eTypedefToTypeWithUID: |
| if (m_encoding_uid != LLDB_INVALID_UID) |
| { |
| Type *encoding_type = m_symbol_file->ResolveTypeUID (m_encoding_uid); |
| if (encoding_type) |
| m_byte_size = encoding_type->GetByteSize(); |
| } |
| if (m_byte_size == 0) |
| { |
| uint64_t bit_width = GetClangAST()->getTypeSize(clang::QualType::getFromOpaquePtr(GetOpaqueClangQualType())); |
| m_byte_size = (bit_width + 7 ) / 8; |
| } |
| break; |
| |
| // If we are a pointer or reference, then this is just a pointer size; |
| case ePointerToTypeWithUID: |
| case eLValueReferenceToTypeWithUID: |
| case eRValueReferenceToTypeWithUID: |
| m_byte_size = GetTypeList()->GetClangASTContext().GetPointerBitSize() / 8; |
| break; |
| } |
| } |
| return m_byte_size; |
| } |
| |
| |
| uint32_t |
| lldb_private::Type::GetNumChildren (bool omit_empty_base_classes) |
| { |
| if (!ResolveClangType()) |
| return 0; |
| return ClangASTContext::GetNumChildren (m_clang_qual_type, omit_empty_base_classes); |
| |
| } |
| |
| bool |
| lldb_private::Type::IsAggregateType () |
| { |
| if (ResolveClangType()) |
| return ClangASTContext::IsAggregateType (m_clang_qual_type); |
| return false; |
| } |
| |
| lldb::Format |
| lldb_private::Type::GetFormat () |
| { |
| // Make sure we resolve our type if it already hasn't been. |
| if (!ResolveClangType()) |
| return lldb::eFormatInvalid; |
| return lldb_private::Type::GetFormat (m_clang_qual_type); |
| } |
| |
| |
| lldb::Format |
| lldb_private::Type::GetFormat (void *clang_type) |
| { |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| |
| switch (qual_type->getTypeClass()) |
| { |
| 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 (cast<clang::BuiltinType>(qual_type)->getKind()) |
| { |
| default: assert(0 && "Unknown builtin type!"); |
| case clang::BuiltinType::Void: |
| break; |
| |
| case clang::BuiltinType::Bool: return lldb::eFormatBoolean; |
| case clang::BuiltinType::Char_S: |
| case clang::BuiltinType::SChar: |
| case clang::BuiltinType::Char_U: |
| case clang::BuiltinType::UChar: |
| case clang::BuiltinType::WChar: return lldb::eFormatChar; |
| case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; |
| case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; |
| case clang::BuiltinType::UShort: return lldb::eFormatHex; |
| case clang::BuiltinType::Short: return lldb::eFormatDecimal; |
| case clang::BuiltinType::UInt: return lldb::eFormatHex; |
| case clang::BuiltinType::Int: return lldb::eFormatDecimal; |
| case clang::BuiltinType::ULong: return lldb::eFormatHex; |
| case clang::BuiltinType::Long: return lldb::eFormatDecimal; |
| case clang::BuiltinType::ULongLong: return lldb::eFormatHex; |
| case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; |
| case clang::BuiltinType::UInt128: return lldb::eFormatHex; |
| 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: 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: return lldb::eFormatComplex; |
| case clang::Type::ObjCInterface: break; |
| case clang::Type::Record: break; |
| case clang::Type::Enum: return lldb::eFormatEnum; |
| case clang::Type::Typedef: |
| return lldb_private::Type::GetFormat(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr()); |
| |
| case clang::Type::TypeOfExpr: |
| case clang::Type::TypeOf: |
| case clang::Type::Decltype: |
| // case clang::Type::QualifiedName: |
| case clang::Type::TemplateSpecialization: break; |
| } |
| // We don't know hot to display this type... |
| return lldb::eFormatBytes; |
| } |
| |
| |
| lldb::Encoding |
| lldb_private::Type::GetEncoding (uint32_t &count) |
| { |
| // Make sure we resolve our type if it already hasn't been. |
| if (!ResolveClangType()) |
| return lldb::eEncodingInvalid; |
| |
| return Type::GetEncoding (m_clang_qual_type, count); |
| } |
| |
| |
| lldb::Encoding |
| lldb_private::Type::GetEncoding (void *clang_type, uint32_t &count) |
| { |
| count = 1; |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); |
| |
| switch (qual_type->getTypeClass()) |
| { |
| 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 (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: |
| 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::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::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; |
| // Complex numbers are made up of floats |
| case clang::Type::Complex: |
| count = 2; |
| return lldb::eEncodingIEEE754; |
| |
| case clang::Type::ObjCInterface: break; |
| case clang::Type::Record: break; |
| case clang::Type::Enum: return lldb::eEncodingSint; |
| case clang::Type::Typedef: |
| return Type::GetEncoding(cast<clang::TypedefType>(qual_type)->LookThroughTypedefs().getAsOpaquePtr(), count); |
| break; |
| |
| case clang::Type::TypeOfExpr: |
| case clang::Type::TypeOf: |
| case clang::Type::Decltype: |
| // case clang::Type::QualifiedName: |
| case clang::Type::TemplateSpecialization: break; |
| } |
| count = 0; |
| return lldb::eEncodingInvalid; |
| } |
| |
| |
| bool |
| lldb_private::Type::DumpValueInMemory |
| ( |
| lldb_private::ExecutionContext *exe_ctx, |
| lldb_private::Stream *s, |
| lldb::addr_t address, |
| lldb::AddressType address_type, |
| bool show_types, |
| bool show_summary, |
| bool verbose |
| ) |
| { |
| if (address != LLDB_INVALID_ADDRESS) |
| { |
| lldb_private::DataExtractor data; |
| data.SetByteOrder (exe_ctx->process->GetByteOrder()); |
| if (ReadFromMemory (exe_ctx, address, address_type, data)) |
| { |
| DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool |
| lldb_private::Type::ReadFromMemory |
| ( |
| lldb_private::ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| void *clang_type, |
| lldb::addr_t addr, |
| lldb::AddressType address_type, |
| lldb_private::DataExtractor &data |
| ) |
| { |
| if (address_type == lldb::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 (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 == lldb::eAddressTypeHost) |
| { |
| // The address is an address in this process, so just copy it |
| memcpy (dst, (uint8_t*)NULL + addr, byte_size); |
| return true; |
| } |
| else |
| { |
| if (exe_ctx && exe_ctx->process) |
| { |
| Error error; |
| return exe_ctx->process->ReadMemory(addr, dst, byte_size, error) == byte_size; |
| } |
| } |
| } |
| return false; |
| } |
| |
| bool |
| lldb_private::Type::WriteToMemory |
| ( |
| lldb_private::ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| void *clang_type, |
| lldb::addr_t addr, |
| lldb::AddressType address_type, |
| StreamString &new_value |
| ) |
| { |
| if (address_type == lldb::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 == lldb::eAddressTypeHost) |
| { |
| // The address is an address in this process, so just copy it |
| memcpy ((void *)addr, new_value.GetData(), byte_size); |
| return true; |
| } |
| else |
| { |
| if (exe_ctx && exe_ctx->process) |
| { |
| Error error; |
| return exe_ctx->process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; |
| } |
| } |
| } |
| return false; |
| } |
| |
| |
| bool |
| lldb_private::Type::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx, lldb::addr_t addr, lldb::AddressType address_type, lldb_private::DataExtractor &data) |
| { |
| if (address_type == lldb::eAddressTypeFile) |
| { |
| // Can't convert a file address to anything valid without more |
| // context (which Module it came from) |
| return false; |
| } |
| |
| const uint32_t byte_size = GetByteSize(); |
| 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 == lldb::eAddressTypeHost) |
| { |
| // The address is an address in this process, so just copy it |
| memcpy (dst, (uint8_t*)NULL + addr, byte_size); |
| return true; |
| } |
| else |
| { |
| if (exe_ctx && exe_ctx->process) |
| { |
| Error error; |
| return exe_ctx->process->ReadMemory(addr, dst, byte_size, error) == byte_size; |
| } |
| } |
| } |
| return false; |
| } |
| |
| |
| bool |
| lldb_private::Type::WriteToMemory (lldb_private::ExecutionContext *exe_ctx, lldb::addr_t addr, lldb::AddressType address_type, lldb_private::DataExtractor &data) |
| { |
| return false; |
| } |
| |
| |
| lldb_private::TypeList* |
| lldb_private::Type::GetTypeList() |
| { |
| return GetSymbolFile()->GetObjectFile()->GetModule()->GetTypeList(); |
| } |
| |
| |
| bool |
| lldb_private::Type::ResolveClangType() |
| { |
| clang::QualType qual_type(clang::QualType::getFromOpaquePtr(m_clang_qual_type)); |
| if (qual_type.getTypePtr() == NULL) |
| { |
| clang::QualType resolved_qual_type; |
| TypeList *type_list = GetTypeList(); |
| if (m_encoding_uid != LLDB_INVALID_UID) |
| { |
| Type *encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid); |
| if (encoding_type) |
| { |
| |
| switch (m_encoding_uid_type) |
| { |
| case eIsTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(encoding_type->GetOpaqueClangQualType()); |
| break; |
| |
| case eIsConstTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(ClangASTContext::AddConstModifier (encoding_type->GetOpaqueClangQualType())); |
| break; |
| |
| case eIsRestrictTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(ClangASTContext::AddRestrictModifier (encoding_type->GetOpaqueClangQualType())); |
| break; |
| |
| case eIsVolatileTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(ClangASTContext::AddVolatileModifier (encoding_type->GetOpaqueClangQualType())); |
| break; |
| |
| case eTypedefToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->CreateClangTypedefType (this, encoding_type)); |
| // Clear the name so it can get fully qualified in case the |
| // typedef is in a namespace. |
| m_name.Clear(); |
| break; |
| |
| case ePointerToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->CreateClangPointerType (encoding_type)); |
| break; |
| |
| case eLValueReferenceToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->CreateClangLValueReferenceType (encoding_type)); |
| break; |
| |
| case eRValueReferenceToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->CreateClangRValueReferenceType (encoding_type)); |
| break; |
| |
| default: |
| assert(!"Unhandled encoding_uid_type."); |
| break; |
| } |
| } |
| } |
| else |
| { |
| // We have no encoding type, return void? |
| void *void_clang_type = type_list->GetClangASTContext().GetVoidBuiltInType(); |
| switch (m_encoding_uid_type) |
| { |
| case eIsTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(void_clang_type); |
| break; |
| |
| case eIsConstTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr (ClangASTContext::AddConstModifier (void_clang_type)); |
| break; |
| |
| case eIsRestrictTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr (ClangASTContext::AddRestrictModifier (void_clang_type)); |
| break; |
| |
| case eIsVolatileTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr (ClangASTContext::AddVolatileModifier (void_clang_type)); |
| break; |
| |
| case eTypedefToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->GetClangASTContext().CreateTypedefType (m_name.AsCString(), void_clang_type, NULL)); |
| break; |
| |
| case ePointerToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->GetClangASTContext().CreatePointerType (void_clang_type)); |
| break; |
| |
| case eLValueReferenceToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->GetClangASTContext().CreateLValueReferenceType (void_clang_type)); |
| break; |
| |
| case eRValueReferenceToTypeWithUID: |
| resolved_qual_type = clang::QualType::getFromOpaquePtr(type_list->GetClangASTContext().CreateRValueReferenceType (void_clang_type)); |
| break; |
| |
| default: |
| assert(!"Unhandled encoding_uid_type."); |
| break; |
| } |
| } |
| if (resolved_qual_type.getTypePtr()) |
| { |
| m_clang_qual_type = resolved_qual_type.getAsOpaquePtr(); |
| } |
| |
| } |
| return m_clang_qual_type != NULL; |
| } |
| |
| void * |
| lldb_private::Type::GetChildClangTypeAtIndex |
| ( |
| const char *parent_name, |
| uint32_t idx, |
| bool transparent_pointers, |
| bool omit_empty_base_classes, |
| ConstString& name, |
| uint32_t &child_byte_size, |
| int32_t &child_byte_offset, |
| uint32_t &child_bitfield_bit_size, |
| uint32_t &child_bitfield_bit_offset |
| ) |
| { |
| if (!ResolveClangType()) |
| return false; |
| |
| std::string name_str; |
| void *child_qual_type = GetClangASTContext().GetChildClangTypeAtIndex ( |
| parent_name, |
| m_clang_qual_type, |
| idx, |
| transparent_pointers, |
| omit_empty_base_classes, |
| name_str, |
| child_byte_size, |
| child_byte_offset, |
| child_bitfield_bit_size, |
| child_bitfield_bit_offset); |
| |
| if (child_qual_type) |
| { |
| if (!name_str.empty()) |
| name.SetCString(name_str.c_str()); |
| else |
| name.Clear(); |
| } |
| return child_qual_type; |
| } |
| |
| |
| |
| void * |
| lldb_private::Type::GetOpaqueClangQualType () |
| { |
| ResolveClangType(); |
| return m_clang_qual_type; |
| } |
| |
| clang::ASTContext * |
| lldb_private::Type::GetClangAST () |
| { |
| TypeList *type_list = GetTypeList(); |
| if (type_list) |
| return type_list->GetClangASTContext().getASTContext(); |
| return NULL; |
| } |
| |
| lldb_private::ClangASTContext & |
| lldb_private::Type::GetClangASTContext () |
| { |
| return GetTypeList()->GetClangASTContext(); |
| } |
| |
| int |
| lldb_private::Type::Compare(const Type &a, const Type &b) |
| { |
| // Just compare the UID values for now... |
| lldb::user_id_t a_uid = a.GetID(); |
| lldb::user_id_t b_uid = b.GetID(); |
| if (a_uid < b_uid) |
| return -1; |
| if (a_uid > b_uid) |
| return 1; |
| return 0; |
| // if (a.getQualType() == b.getQualType()) |
| // return 0; |
| } |
| |