aboutsummaryrefslogtreecommitdiff
path: root/source/Symbol/ClangASTType.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/Symbol/ClangASTType.cpp')
-rw-r--r--source/Symbol/ClangASTType.cpp2158
1 files changed, 1168 insertions, 990 deletions
diff --git a/source/Symbol/ClangASTType.cpp b/source/Symbol/ClangASTType.cpp
index 40f6462ee360..a0878ae442c8 100644
--- a/source/Symbol/ClangASTType.cpp
+++ b/source/Symbol/ClangASTType.cpp
@@ -22,6 +22,7 @@
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/Type.h"
+#include "clang/AST/VTableBuilder.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/IdentifierTable.h"
@@ -50,11 +51,9 @@
using namespace lldb;
using namespace lldb_private;
-using namespace clang;
-using namespace llvm;
static bool
-GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion = true)
+GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true)
{
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -63,7 +62,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
case clang::Type::IncompleteArray:
case clang::Type::VariableArray:
{
- const ArrayType *array_type = dyn_cast<ArrayType>(qual_type.getTypePtr());
+ const clang::ArrayType *array_type = llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
if (array_type)
return GetCompleteQualType (ast, array_type->getElementType(), allow_completion);
@@ -73,10 +72,10 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
case clang::Type::Record:
case clang::Type::Enum:
{
- const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
if (tag_type)
{
- TagDecl *tag_decl = tag_type->getDecl();
+ clang::TagDecl *tag_decl = tag_type->getDecl();
if (tag_decl)
{
if (tag_decl->isCompleteDefinition())
@@ -89,7 +88,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
{
if (ast)
{
- ExternalASTSource *external_ast_source = ast->getExternalSource();
+ clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
if (external_ast_source)
{
external_ast_source->CompleteType(tag_decl);
@@ -107,10 +106,10 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
case clang::Type::ObjCObject:
case clang::Type::ObjCInterface:
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
// We currently can't complete objective C types through the newly added ASTContext
// because it only supports TagDecl objects right now...
if (class_interface_decl)
@@ -125,7 +124,7 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
{
if (ast)
{
- ExternalASTSource *external_ast_source = ast->getExternalSource();
+ clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
if (external_ast_source)
{
external_ast_source->CompleteType (class_interface_decl);
@@ -140,13 +139,13 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
break;
case clang::Type::Typedef:
- return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
+ return GetCompleteQualType (ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
case clang::Type::Elaborated:
- return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion);
+ return GetCompleteQualType (ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(), allow_completion);
case clang::Type::Paren:
- return GetCompleteQualType (ast, cast<ParenType>(qual_type)->desugar(), allow_completion);
+ return GetCompleteQualType (ast, llvm::cast<clang::ParenType>(qual_type)->desugar(), allow_completion);
default:
break;
@@ -155,18 +154,18 @@ GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion
return true;
}
-static ObjCIvarDecl::AccessControl
+static clang::ObjCIvarDecl::AccessControl
ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
{
switch (access)
{
- case eAccessNone: return ObjCIvarDecl::None;
- case eAccessPublic: return ObjCIvarDecl::Public;
- case eAccessPrivate: return ObjCIvarDecl::Private;
- case eAccessProtected: return ObjCIvarDecl::Protected;
- case eAccessPackage: return ObjCIvarDecl::Package;
+ case eAccessNone: return clang::ObjCIvarDecl::None;
+ case eAccessPublic: return clang::ObjCIvarDecl::Public;
+ case eAccessPrivate: return clang::ObjCIvarDecl::Private;
+ case eAccessProtected: return clang::ObjCIvarDecl::Protected;
+ case eAccessPackage: return clang::ObjCIvarDecl::Package;
}
- return ObjCIvarDecl::None;
+ return clang::ObjCIvarDecl::None;
}
//----------------------------------------------------------------------
@@ -194,7 +193,7 @@ ClangASTType::IsAggregateType () const
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -209,11 +208,11 @@ ClangASTType::IsAggregateType () const
case clang::Type::ObjCInterface:
return true;
case clang::Type::Elaborated:
- return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsAggregateType();
+ return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsAggregateType();
case clang::Type::Typedef:
- return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType();
+ return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType();
case clang::Type::Paren:
- return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).IsAggregateType();
+ return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsAggregateType();
default:
break;
}
@@ -228,7 +227,7 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr,
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -238,14 +237,14 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr,
case clang::Type::ConstantArray:
if (element_type_ptr)
- element_type_ptr->SetClangType (m_ast, cast<ConstantArrayType>(qual_type)->getElementType());
+ element_type_ptr->SetClangType (m_ast, llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType());
if (size)
- *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
+ *size = llvm::cast<clang::ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
return true;
case clang::Type::IncompleteArray:
if (element_type_ptr)
- element_type_ptr->SetClangType (m_ast, cast<IncompleteArrayType>(qual_type)->getElementType());
+ element_type_ptr->SetClangType (m_ast, llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType());
if (size)
*size = 0;
if (is_incomplete)
@@ -254,28 +253,28 @@ ClangASTType::IsArrayType (ClangASTType *element_type_ptr,
case clang::Type::VariableArray:
if (element_type_ptr)
- element_type_ptr->SetClangType (m_ast, cast<VariableArrayType>(qual_type)->getElementType());
+ element_type_ptr->SetClangType (m_ast, llvm::cast<clang::VariableArrayType>(qual_type)->getElementType());
if (size)
*size = 0;
return true;
case clang::Type::DependentSizedArray:
if (element_type_ptr)
- element_type_ptr->SetClangType (m_ast, cast<DependentSizedArrayType>(qual_type)->getElementType());
+ element_type_ptr->SetClangType (m_ast, llvm::cast<clang::DependentSizedArrayType>(qual_type)->getElementType());
if (size)
*size = 0;
return true;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr,
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr,
size,
is_incomplete);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr,
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr,
size,
is_incomplete);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr,
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr,
size,
is_incomplete);
}
@@ -352,7 +351,7 @@ ClangASTType::IsCStringType (uint32_t &length) const
{
// We know the size of the array and it could be a C string
// since it is an array of characters
- length = cast<ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue();
+ length = llvm::cast<clang::ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue();
}
return true;
@@ -366,7 +365,7 @@ ClangASTType::IsFunctionType (bool *is_variadic_ptr) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
if (qual_type->isFunctionType())
{
@@ -387,16 +386,16 @@ ClangASTType::IsFunctionType (bool *is_variadic_ptr) const
default:
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType();
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType();
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionType();
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsFunctionType();
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType();
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType();
case clang::Type::LValueReference:
case clang::Type::RValueReference:
{
- const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
if (reference_type)
return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType();
}
@@ -406,13 +405,109 @@ ClangASTType::IsFunctionType (bool *is_variadic_ptr) const
return false;
}
+// Used to detect "Homogeneous Floating-point Aggregates"
+uint32_t
+ClangASTType::IsHomogeneousAggregate (ClangASTType* base_type_ptr) const
+{
+ if (!IsValid())
+ return 0;
+
+ clang::QualType qual_type(GetCanonicalQualType());
+ const clang::Type::TypeClass type_class = qual_type->getTypeClass();
+ switch (type_class)
+ {
+ case clang::Type::Record:
+ if (GetCompleteType ())
+ {
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ if (cxx_record_decl)
+ {
+ if (cxx_record_decl->getNumBases() ||
+ cxx_record_decl->isDynamicClass())
+ return 0;
+ }
+ const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
+ if (record_type)
+ {
+ const clang::RecordDecl *record_decl = record_type->getDecl();
+ if (record_decl)
+ {
+ // We are looking for a structure that contains only floating point types
+ clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end();
+ uint32_t num_fields = 0;
+ bool is_hva = false;
+ bool is_hfa = false;
+ clang::QualType base_qual_type;
+ for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos)
+ {
+ clang::QualType field_qual_type = field_pos->getType();
+ if (field_qual_type->isFloatingType())
+ {
+ if (field_qual_type->isComplexType())
+ return 0;
+ else
+ {
+ if (num_fields == 0)
+ base_qual_type = field_qual_type;
+ else
+ {
+ if (is_hva)
+ return 0;
+ is_hfa = true;
+ if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
+ return 0;
+ }
+ }
+ }
+ else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType())
+ {
+ const clang::VectorType *array = llvm::cast<clang::VectorType>(field_qual_type.getTypePtr());
+ if (array && array->getNumElements() <= 4)
+ {
+ if (num_fields == 0)
+ base_qual_type = array->getElementType();
+ else
+ {
+ if (is_hfa)
+ return 0;
+ is_hva = true;
+ if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
+ return 0;
+ }
+ }
+ else
+ return 0;
+ }
+ else
+ return 0;
+ ++num_fields;
+ }
+ if (base_type_ptr)
+ *base_type_ptr = ClangASTType (m_ast, base_qual_type);
+ return num_fields;
+ }
+ }
+ }
+ break;
+
+ case clang::Type::Typedef:
+ return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsHomogeneousAggregate (base_type_ptr);
+
+ case clang::Type::Elaborated:
+ return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsHomogeneousAggregate (base_type_ptr);
+ default:
+ break;
+ }
+ return 0;
+}
+
size_t
ClangASTType::GetNumberOfFunctionArguments () const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
- const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
+ clang::QualType qual_type (GetCanonicalQualType());
+ const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
if (func)
return func->getNumParams();
}
@@ -424,8 +519,8 @@ ClangASTType::GetFunctionArgumentAtIndex (const size_t index)
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
- const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
+ clang::QualType qual_type (GetCanonicalQualType());
+ const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
if (func)
{
if (index < func->getNumParams())
@@ -440,7 +535,7 @@ ClangASTType::IsFunctionPointerType () const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
if (qual_type->isFunctionPointerType())
return true;
@@ -451,16 +546,16 @@ ClangASTType::IsFunctionPointerType () const
default:
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType();
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType();
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType();
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType();
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType();
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType();
case clang::Type::LValueReference:
case clang::Type::RValueReference:
{
- const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
if (reference_type)
return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType();
}
@@ -477,8 +572,8 @@ ClangASTType::IsIntegerType (bool &is_signed) const
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
- const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
+ clang::QualType qual_type (GetCanonicalQualType());
+ const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
if (builtin_type)
{
@@ -497,12 +592,12 @@ ClangASTType::IsPointerType (ClangASTType *pointee_type) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
- switch (cast<clang::BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
default:
break;
@@ -513,26 +608,26 @@ ClangASTType::IsPointerType (ClangASTType *pointee_type) const
return false;
case clang::Type::ObjCObjectPointer:
if (pointee_type)
- pointee_type->SetClangType (m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::BlockPointer:
if (pointee_type)
- pointee_type->SetClangType (m_ast, cast<BlockPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType (m_ast, llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::Pointer:
if (pointee_type)
- pointee_type->SetClangType (m_ast, cast<PointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType (m_ast, llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::MemberPointer:
if (pointee_type)
- pointee_type->SetClangType (m_ast, cast<MemberPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType (m_ast, llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type);
default:
break;
}
@@ -548,12 +643,12 @@ ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
- switch (cast<clang::BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
default:
break;
@@ -564,34 +659,34 @@ ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const
return false;
case clang::Type::ObjCObjectPointer:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::BlockPointer:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<BlockPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::Pointer:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<PointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::MemberPointer:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<MemberPointerType>(qual_type)->getPointeeType());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
return true;
case clang::Type::LValueReference:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
return true;
case clang::Type::RValueReference:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
return true;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type);
default:
break;
}
@@ -603,29 +698,33 @@ ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const
bool
-ClangASTType::IsReferenceType (ClangASTType *pointee_type) const
+ClangASTType::IsReferenceType (ClangASTType *pointee_type, bool* is_rvalue) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::LValueReference:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
+ if (is_rvalue)
+ *is_rvalue = false;
return true;
case clang::Type::RValueReference:
if (pointee_type)
- pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
+ pointee_type->SetClangType(m_ast, llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
+ if (is_rvalue)
+ *is_rvalue = true;
return true;
case clang::Type::Typedef:
- return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type);
+ return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type, is_rvalue);
case clang::Type::Elaborated:
- return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type);
+ return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type, is_rvalue);
case clang::Type::Paren:
- return ClangASTType(m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type);
+ return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type, is_rvalue);
default:
break;
@@ -641,19 +740,19 @@ ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
- if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
+ if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()))
{
clang::BuiltinType::Kind kind = BT->getKind();
- if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
+ if (kind >= clang::BuiltinType::Float && kind <= clang::BuiltinType::LongDouble)
{
count = 1;
is_complex = false;
return true;
}
}
- else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
+ else if (const clang::ComplexType *CT = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal()))
{
if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex))
{
@@ -662,7 +761,7 @@ ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
return true;
}
}
- else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
+ else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal()))
{
if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex))
{
@@ -684,23 +783,23 @@ ClangASTType::IsDefined() const
if (!IsValid())
return false;
- QualType qual_type(GetQualType());
- const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
+ clang::QualType qual_type(GetQualType());
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
if (tag_type)
{
- TagDecl *tag_decl = tag_type->getDecl();
+ clang::TagDecl *tag_decl = tag_type->getDecl();
if (tag_decl)
return tag_decl->isCompleteDefinition();
return false;
}
else
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
- return class_interface_decl->getDefinition() != NULL;
+ return class_interface_decl->getDefinition() != nullptr;
return false;
}
}
@@ -712,9 +811,9 @@ ClangASTType::IsObjCClassType () const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
- const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type);
+ const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
if (obj_pointer_type)
return obj_pointer_type->isObjCClassType();
@@ -735,18 +834,18 @@ ClangASTType::IsPolymorphicClass () const
{
if (IsValid())
{
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
+ const clang::RecordDecl *record_decl = record_type->getDecl();
if (record_decl)
{
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
if (cxx_record_decl)
return cxx_record_decl->isPolymorphic();
}
@@ -765,16 +864,16 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
bool check_cplusplus,
bool check_objc) const
{
- QualType pointee_qual_type;
+ clang::QualType pointee_qual_type;
if (m_type)
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
bool success = false;
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
- if (check_objc && cast<BuiltinType>(qual_type)->getKind() == BuiltinType::ObjCId)
+ if (check_objc && llvm::cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId)
{
if (dynamic_pointee_type)
dynamic_pointee_type->SetClangType(m_ast, m_type);
@@ -786,37 +885,37 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
if (check_objc)
{
if (dynamic_pointee_type)
- dynamic_pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
+ dynamic_pointee_type->SetClangType(m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
return true;
}
break;
case clang::Type::Pointer:
- pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType();
+ pointee_qual_type = llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
success = true;
break;
case clang::Type::LValueReference:
case clang::Type::RValueReference:
- pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType();
+ pointee_qual_type = llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
success = true;
break;
case clang::Type::Typedef:
return ClangASTType (m_ast,
- cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type,
+ llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type,
check_cplusplus,
check_objc);
case clang::Type::Elaborated:
return ClangASTType (m_ast,
- cast<ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type,
+ llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type,
check_cplusplus,
check_objc);
case clang::Type::Paren:
return ClangASTType (m_ast,
- cast<ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type,
+ llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type,
check_cplusplus,
check_objc);
default:
@@ -832,55 +931,55 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
switch (pointee_type_class)
{
case clang::Type::Builtin:
- switch (cast<BuiltinType>(pointee_qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind())
{
- case BuiltinType::UnknownAny:
- case BuiltinType::Void:
+ case clang::BuiltinType::UnknownAny:
+ case clang::BuiltinType::Void:
if (dynamic_pointee_type)
dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
return true;
- case BuiltinType::NullPtr:
- case BuiltinType::Bool:
- case BuiltinType::Char_U:
- case BuiltinType::UChar:
- case BuiltinType::WChar_U:
- case BuiltinType::Char16:
- case BuiltinType::Char32:
- case BuiltinType::UShort:
- case BuiltinType::UInt:
- case BuiltinType::ULong:
- case BuiltinType::ULongLong:
- case BuiltinType::UInt128:
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- case BuiltinType::WChar_S:
- case BuiltinType::Short:
- case BuiltinType::Int:
- case BuiltinType::Long:
- case BuiltinType::LongLong:
- case BuiltinType::Int128:
- case BuiltinType::Float:
- case BuiltinType::Double:
- case BuiltinType::LongDouble:
- case BuiltinType::Dependent:
- case BuiltinType::Overload:
- case BuiltinType::ObjCId:
- case BuiltinType::ObjCClass:
- case BuiltinType::ObjCSel:
- case BuiltinType::BoundMember:
- case BuiltinType::Half:
- case BuiltinType::ARCUnbridgedCast:
- case BuiltinType::PseudoObject:
- case BuiltinType::BuiltinFn:
- case BuiltinType::OCLEvent:
- case BuiltinType::OCLImage1d:
- case BuiltinType::OCLImage1dArray:
- case BuiltinType::OCLImage1dBuffer:
- case BuiltinType::OCLImage2d:
- case BuiltinType::OCLImage2dArray:
- case BuiltinType::OCLImage3d:
- case BuiltinType::OCLSampler:
+ case clang::BuiltinType::NullPtr:
+ 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:
+ case clang::BuiltinType::Dependent:
+ case clang::BuiltinType::Overload:
+ case clang::BuiltinType::ObjCId:
+ case clang::BuiltinType::ObjCClass:
+ case clang::BuiltinType::ObjCSel:
+ case clang::BuiltinType::BoundMember:
+ case clang::BuiltinType::Half:
+ case clang::BuiltinType::ARCUnbridgedCast:
+ case clang::BuiltinType::PseudoObject:
+ case clang::BuiltinType::BuiltinFn:
+ case clang::BuiltinType::OCLEvent:
+ case clang::BuiltinType::OCLImage1d:
+ case clang::BuiltinType::OCLImage1dArray:
+ case clang::BuiltinType::OCLImage1dBuffer:
+ case clang::BuiltinType::OCLImage2d:
+ case clang::BuiltinType::OCLImage2dArray:
+ case clang::BuiltinType::OCLImage3d:
+ case clang::BuiltinType::OCLSampler:
break;
}
break;
@@ -888,7 +987,7 @@ ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
case clang::Type::Record:
if (check_cplusplus)
{
- CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
bool is_complete = cxx_record_decl->isCompleteDefinition();
@@ -947,7 +1046,7 @@ ClangASTType::IsScalarType () const
if (!IsValid())
return false;
- return (GetTypeInfo (NULL) & eTypeIsScalar) != 0;
+ return (GetTypeInfo (nullptr) & eTypeIsScalar) != 0;
}
bool
@@ -979,7 +1078,7 @@ bool
ClangASTType::IsArrayOfScalarType () const
{
ClangASTType element_type;
- if (IsArrayType(&element_type, NULL, NULL))
+ if (IsArrayType(&element_type, nullptr, nullptr))
return element_type.IsScalarType();
return false;
}
@@ -990,9 +1089,9 @@ ClangASTType::GetCXXClassName (std::string &class_name) const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
- CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
@@ -1010,8 +1109,8 @@ ClangASTType::IsCXXClassType () const
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
- if (qual_type->getAsCXXRecordDecl() != NULL)
+ clang::QualType qual_type (GetCanonicalQualType());
+ if (qual_type->getAsCXXRecordDecl() != nullptr)
return true;
return false;
}
@@ -1021,8 +1120,8 @@ ClangASTType::IsBeingDefined () const
{
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
- const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type);
+ clang::QualType qual_type (GetCanonicalQualType());
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
if (tag_type)
return tag_type->isBeingDefined();
return false;
@@ -1034,7 +1133,7 @@ ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr)
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
if (qual_type->isObjCObjectPointerType())
{
@@ -1043,11 +1142,11 @@ ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr)
if (!qual_type->isObjCClassType() &&
!qual_type->isObjCIdType())
{
- const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type);
- if (obj_pointer_type == NULL)
+ const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
+ if (obj_pointer_type == nullptr)
class_type_ptr->Clear();
else
- class_type_ptr->SetClangType (m_ast, QualType(obj_pointer_type->getInterfaceType(), 0));
+ class_type_ptr->SetClangType (m_ast, clang::QualType(obj_pointer_type->getInterfaceType(), 0));
}
}
return true;
@@ -1063,12 +1162,12 @@ ClangASTType::GetObjCClassName (std::string &class_name)
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
- const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(qual_type);
+ const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
if (object_type)
{
- const ObjCInterfaceDecl *interface = object_type->getInterface();
+ const clang::ObjCInterfaceDecl *interface = object_type->getInterface();
if (interface)
{
class_name = interface->getNameAsString();
@@ -1127,14 +1226,14 @@ ClangASTType::GetTypeName () const
std::string type_name;
if (IsValid())
{
- PrintingPolicy printing_policy (m_ast->getPrintingPolicy());
- QualType qual_type(GetQualType());
+ clang::PrintingPolicy printing_policy (m_ast->getPrintingPolicy());
+ clang::QualType qual_type(GetQualType());
printing_policy.SuppressTagKeyword = true;
printing_policy.LangOpts.WChar = true;
- const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
+ const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
if (typedef_type)
{
- const TypedefNameDecl *typedef_decl = typedef_type->getDecl();
+ const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
type_name = typedef_decl->getQualifiedNameAsString();
}
else
@@ -1145,6 +1244,11 @@ ClangASTType::GetTypeName () const
return ConstString(type_name);
}
+ConstString
+ClangASTType::GetDisplayTypeName () const
+{
+ return GetTypeName();
+}
uint32_t
ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
@@ -1155,14 +1259,14 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
if (pointee_or_element_clang_type)
pointee_or_element_clang_type->Clear();
- QualType qual_type (GetQualType());
+ clang::QualType qual_type (GetQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
{
- const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
+ const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
switch (builtin_type->getKind())
@@ -1226,10 +1330,10 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::Complex:
{
uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
- const ComplexType *complex_type = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal());
+ const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal());
if (complex_type)
{
- QualType complex_element_type (complex_type->getElementType());
+ clang::QualType complex_element_type (complex_type->getElementType());
if (complex_element_type->isIntegerType())
complex_type_flags |= eTypeIsFloat;
else if (complex_element_type->isFloatingType())
@@ -1244,7 +1348,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::IncompleteArray:
case clang::Type::VariableArray:
if (pointee_or_element_clang_type)
- pointee_or_element_clang_type->SetClangType(m_ast, cast<ArrayType>(qual_type.getTypePtr())->getElementType());
+ pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())->getElementType());
return eTypeHasChildren | eTypeIsArray;
case clang::Type::DependentName: return 0;
@@ -1254,13 +1358,13 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::Enum:
if (pointee_or_element_clang_type)
- pointee_or_element_clang_type->SetClangType(m_ast, cast<EnumType>(qual_type)->getDecl()->getIntegerType());
+ pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType());
return eTypeIsEnumeration | eTypeHasValue;
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type);
case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue;
case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue;
@@ -1269,7 +1373,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::LValueReference:
case clang::Type::RValueReference:
if (pointee_or_element_clang_type)
- pointee_or_element_clang_type->SetClangType(m_ast, cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType());
+ pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())->getPointeeType());
return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
@@ -1298,7 +1402,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::TemplateSpecialization: return eTypeIsTemplate;
case clang::Type::Typedef:
- return eTypeIsTypedef | ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type);
+ return eTypeIsTypedef | ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type);
case clang::Type::TypeOfExpr: return 0;
case clang::Type::TypeOf: return 0;
case clang::Type::UnresolvedUsing: return 0;
@@ -1307,7 +1411,7 @@ ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
case clang::Type::Vector:
{
uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
- const VectorType *vector_type = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal());
+ const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal());
if (vector_type)
{
if (vector_type->isIntegerType())
@@ -1331,14 +1435,14 @@ ClangASTType::GetMinimumLanguage ()
return lldb::eLanguageTypeC;
// If the type is a reference, then resolve it to what it refers to first:
- QualType qual_type (GetCanonicalQualType().getNonReferenceType());
+ clang::QualType qual_type (GetCanonicalQualType().getNonReferenceType());
if (qual_type->isAnyPointerType())
{
if (qual_type->isObjCObjectPointerType())
return lldb::eLanguageTypeObjC;
- QualType pointee_type (qual_type->getPointeeType());
- if (pointee_type->getPointeeCXXRecordDecl() != NULL)
+ clang::QualType pointee_type (qual_type->getPointeeType());
+ if (pointee_type->getPointeeCXXRecordDecl() != nullptr)
return lldb::eLanguageTypeC_plus_plus;
if (pointee_type->isObjCObjectOrInterfaceType())
return lldb::eLanguageTypeObjC;
@@ -1358,51 +1462,51 @@ ClangASTType::GetMinimumLanguage ()
default:
break;
case clang::Type::Builtin:
- switch (cast<BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
default:
- case BuiltinType::Void:
- case BuiltinType::Bool:
- case BuiltinType::Char_U:
- case BuiltinType::UChar:
- case BuiltinType::WChar_U:
- case BuiltinType::Char16:
- case BuiltinType::Char32:
- case BuiltinType::UShort:
- case BuiltinType::UInt:
- case BuiltinType::ULong:
- case BuiltinType::ULongLong:
- case BuiltinType::UInt128:
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- case BuiltinType::WChar_S:
- case BuiltinType::Short:
- case BuiltinType::Int:
- case BuiltinType::Long:
- case BuiltinType::LongLong:
- case BuiltinType::Int128:
- case BuiltinType::Float:
- case BuiltinType::Double:
- case BuiltinType::LongDouble:
+ 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 BuiltinType::NullPtr:
+ case clang::BuiltinType::NullPtr:
return eLanguageTypeC_plus_plus;
- case BuiltinType::ObjCId:
- case BuiltinType::ObjCClass:
- case BuiltinType::ObjCSel:
+ case clang::BuiltinType::ObjCId:
+ case clang::BuiltinType::ObjCClass:
+ case clang::BuiltinType::ObjCSel:
return eLanguageTypeObjC;
- case BuiltinType::Dependent:
- case BuiltinType::Overload:
- case BuiltinType::BoundMember:
- case BuiltinType::UnknownAny:
+ case clang::BuiltinType::Dependent:
+ case clang::BuiltinType::Overload:
+ case clang::BuiltinType::BoundMember:
+ case clang::BuiltinType::UnknownAny:
break;
}
break;
case clang::Type::Typedef:
- return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
+ return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
}
}
return lldb::eLanguageTypeC;
@@ -1414,7 +1518,7 @@ ClangASTType::GetTypeClass () const
if (!IsValid())
return lldb::eTypeClassInvalid;
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
switch (qual_type->getTypeClass())
{
@@ -1444,8 +1548,8 @@ ClangASTType::GetTypeClass () const
case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface;
case clang::Type::Record:
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ 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())
@@ -1458,9 +1562,9 @@ ClangASTType::GetTypeClass () const
case clang::Type::Typedef: return lldb::eTypeClassTypedef;
case clang::Type::UnresolvedUsing: break;
case clang::Type::Paren:
- return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetTypeClass();
+ return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeClass();
case clang::Type::Elaborated:
- return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeClass();
+ return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeClass();
case clang::Type::Attributed: break;
case clang::Type::TemplateTypeParm: break;
@@ -1480,6 +1584,7 @@ ClangASTType::GetTypeClass () const
// pointer type decayed from an array or function type.
case clang::Type::Decayed: break;
+ case clang::Type::Adjusted: break;
}
// We don't know hot to display this type...
return lldb::eTypeClassOther;
@@ -1510,7 +1615,7 @@ ClangASTType::AddConstModifier () const
{
if (m_type)
{
- QualType result(GetQualType());
+ clang::QualType result(GetQualType());
result.addConst();
return ClangASTType (m_ast, result);
}
@@ -1522,7 +1627,7 @@ ClangASTType::AddRestrictModifier () const
{
if (m_type)
{
- QualType result(GetQualType());
+ clang::QualType result(GetQualType());
result.getQualifiers().setRestrict (true);
return ClangASTType (m_ast, result);
}
@@ -1534,7 +1639,7 @@ ClangASTType::AddVolatileModifier () const
{
if (m_type)
{
- QualType result(GetQualType());
+ clang::QualType result(GetQualType());
result.getQualifiers().setVolatile (true);
return ClangASTType (m_ast, result);
}
@@ -1542,16 +1647,22 @@ ClangASTType::AddVolatileModifier () const
}
ClangASTType
-ClangASTType::GetArrayElementType (uint64_t& stride) const
+ClangASTType::GetArrayElementType (uint64_t *stride) const
{
if (IsValid())
{
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
+
+ const clang::Type *array_elem_type = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
+
+ if (!array_elem_type)
+ return ClangASTType();
- ClangASTType element_type (m_ast, qual_type.getTypePtr()->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified());
+ ClangASTType element_type (m_ast, array_elem_type->getCanonicalTypeUnqualified());
// TODO: the real stride will be >= this value.. find the real one!
- stride = element_type.GetByteSize();
+ if (stride)
+ *stride = element_type.GetByteSize();
return element_type;
@@ -1567,8 +1678,8 @@ ClangASTType::GetCanonicalType () const
return ClangASTType();
}
-static QualType
-GetFullyUnqualifiedType_Impl (ASTContext *ast, QualType qual_type)
+static clang::QualType
+GetFullyUnqualifiedType_Impl (clang::ASTContext *ast, clang::QualType qual_type)
{
if (qual_type->isPointerType())
qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
@@ -1594,7 +1705,7 @@ ClangASTType::GetFunctionArgumentCount () const
{
if (IsValid())
{
- const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType());
+ const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType());
if (func)
return func->getNumParams();
}
@@ -1606,7 +1717,7 @@ ClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx)
{
if (IsValid())
{
- const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType());
+ const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType());
if (func)
{
const uint32_t num_args = func->getNumParams();
@@ -1622,8 +1733,8 @@ ClangASTType::GetFunctionReturnType () const
{
if (IsValid())
{
- QualType qual_type(GetCanonicalQualType());
- const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
+ clang::QualType qual_type(GetCanonicalQualType());
+ const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
if (func)
return ClangASTType(m_ast, func->getReturnType());
}
@@ -1665,19 +1776,19 @@ ClangASTType::CreateTypedefType (const char *typedef_name,
{
if (IsValid() && typedef_name && typedef_name[0])
{
- QualType qual_type (GetQualType());
- if (decl_ctx == NULL)
+ clang::QualType qual_type (GetQualType());
+ if (decl_ctx == nullptr)
decl_ctx = m_ast->getTranslationUnitDecl();
- TypedefDecl *decl = TypedefDecl::Create (*m_ast,
- decl_ctx,
- SourceLocation(),
- SourceLocation(),
- &m_ast->Idents.get(typedef_name),
- m_ast->getTrivialTypeSourceInfo(qual_type));
+ clang::TypedefDecl *decl = clang::TypedefDecl::Create (*m_ast,
+ decl_ctx,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ &m_ast->Idents.get(typedef_name),
+ m_ast->getTrivialTypeSourceInfo(qual_type));
- decl->setAccess(AS_public); // TODO respect proper access specifier
+ decl->setAccess(clang::AS_public); // TODO respect proper access specifier
- // Get a uniqued QualType for the typedef decl type
+ // Get a uniqued clang::QualType for the typedef decl type
return ClangASTType (m_ast, m_ast->getTypedefType (decl));
}
return ClangASTType();
@@ -1689,7 +1800,7 @@ ClangASTType::GetPointeeType () const
{
if (m_type)
{
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType());
}
return ClangASTType();
@@ -1700,7 +1811,7 @@ ClangASTType::GetPointerType () const
{
if (IsValid())
{
- QualType qual_type (GetQualType());
+ clang::QualType qual_type (GetQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -1721,7 +1832,7 @@ ClangASTType::GetTypedefedType () const
{
if (IsValid())
{
- const TypedefType *typedef_type = dyn_cast<TypedefType>(GetQualType());
+ const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType());
if (typedef_type)
return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType());
}
@@ -1733,7 +1844,7 @@ ClangASTType::RemoveFastQualifiers () const
{
if (m_type)
{
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
qual_type.getQualifiers().removeFastQualifiers();
return ClangASTType (m_ast, qual_type);
}
@@ -1761,7 +1872,7 @@ ClangASTType::GetBitSize () const
{
if (GetCompleteType ())
{
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const uint32_t bit_size = m_ast->getTypeSize (qual_type);
if (bit_size == 0)
{
@@ -1797,7 +1908,7 @@ ClangASTType::GetEncoding (uint64_t &count) const
return lldb::eEncodingInvalid;
count = 1;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
switch (qual_type->getTypeClass())
{
@@ -1821,42 +1932,42 @@ ClangASTType::GetEncoding (uint64_t &count) const
break;
case clang::Type::Builtin:
- switch (cast<BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
default: assert(0 && "Unknown builtin type!");
- case BuiltinType::Void:
+ case clang::BuiltinType::Void:
break;
- case BuiltinType::Bool:
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- case BuiltinType::WChar_S:
- case BuiltinType::Char16:
- case BuiltinType::Char32:
- case BuiltinType::Short:
- case BuiltinType::Int:
- case BuiltinType::Long:
- case BuiltinType::LongLong:
- case BuiltinType::Int128: return lldb::eEncodingSint;
+ 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 BuiltinType::Char_U:
- case BuiltinType::UChar:
- case BuiltinType::WChar_U:
- case BuiltinType::UShort:
- case BuiltinType::UInt:
- case BuiltinType::ULong:
- case BuiltinType::ULongLong:
- case BuiltinType::UInt128: return lldb::eEncodingUint;
+ 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 BuiltinType::Float:
- case BuiltinType::Double:
- case BuiltinType::LongDouble: return lldb::eEncodingIEEE754;
+ case clang::BuiltinType::Float:
+ case clang::BuiltinType::Double:
+ case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754;
- case BuiltinType::ObjCClass:
- case BuiltinType::ObjCId:
- case BuiltinType::ObjCSel: return lldb::eEncodingUint;
+ case clang::BuiltinType::ObjCClass:
+ case clang::BuiltinType::ObjCId:
+ case clang::BuiltinType::ObjCSel: return lldb::eEncodingUint;
- case BuiltinType::NullPtr: return lldb::eEncodingUint;
+ case clang::BuiltinType::NullPtr: return lldb::eEncodingUint;
}
break;
// All pointer types are represented as unsigned integer encodings.
@@ -1875,7 +1986,7 @@ ClangASTType::GetEncoding (uint64_t &count) const
encoding = lldb::eEncodingIEEE754;
else
{
- const ComplexType *complex_type = qual_type->getAsComplexIntegerType();
+ const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType();
if (complex_type)
encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count);
else
@@ -1889,13 +2000,13 @@ ClangASTType::GetEncoding (uint64_t &count) const
case clang::Type::Record: break;
case clang::Type::Enum: return lldb::eEncodingSint;
case clang::Type::Typedef:
- return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count);
+ return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count);
case clang::Type::Elaborated:
- return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count);
+ return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count);
case clang::Type::Paren:
- return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetEncoding(count);
+ return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetEncoding(count);
case clang::Type::DependentSizedArray:
case clang::Type::DependentSizedExtVector:
@@ -1916,6 +2027,7 @@ ClangASTType::GetEncoding (uint64_t &count) const
case clang::Type::Decltype:
case clang::Type::TemplateSpecialization:
case clang::Type::Atomic:
+ case clang::Type::Adjusted:
break;
// pointer type decayed from an array or function type.
@@ -1932,7 +2044,7 @@ ClangASTType::GetFormat () const
if (!IsValid())
return lldb::eFormatDefault;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
switch (qual_type->getTypeClass())
{
@@ -1955,54 +2067,54 @@ ClangASTType::GetFormat () const
break;
case clang::Type::Builtin:
- switch (cast<BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
//default: assert(0 && "Unknown builtin type!");
- case BuiltinType::UnknownAny:
- case BuiltinType::Void:
- case BuiltinType::BoundMember:
+ case clang::BuiltinType::UnknownAny:
+ case clang::BuiltinType::Void:
+ case clang::BuiltinType::BoundMember:
break;
- case BuiltinType::Bool: return lldb::eFormatBoolean;
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- case BuiltinType::WChar_S:
- case BuiltinType::Char_U:
- case BuiltinType::UChar:
- case BuiltinType::WChar_U: return lldb::eFormatChar;
- case BuiltinType::Char16: return lldb::eFormatUnicode16;
- case BuiltinType::Char32: return lldb::eFormatUnicode32;
- case BuiltinType::UShort: return lldb::eFormatUnsigned;
- case BuiltinType::Short: return lldb::eFormatDecimal;
- case BuiltinType::UInt: return lldb::eFormatUnsigned;
- case BuiltinType::Int: return lldb::eFormatDecimal;
- case BuiltinType::ULong: return lldb::eFormatUnsigned;
- case BuiltinType::Long: return lldb::eFormatDecimal;
- case BuiltinType::ULongLong: return lldb::eFormatUnsigned;
- case BuiltinType::LongLong: return lldb::eFormatDecimal;
- case BuiltinType::UInt128: return lldb::eFormatUnsigned;
- case BuiltinType::Int128: return lldb::eFormatDecimal;
- case BuiltinType::Float: return lldb::eFormatFloat;
- case BuiltinType::Double: return lldb::eFormatFloat;
- case BuiltinType::LongDouble: return lldb::eFormatFloat;
- case BuiltinType::NullPtr:
- case BuiltinType::Overload:
- case BuiltinType::Dependent:
- case BuiltinType::ObjCId:
- case BuiltinType::ObjCClass:
- case BuiltinType::ObjCSel:
- case BuiltinType::Half:
- case BuiltinType::ARCUnbridgedCast:
- case BuiltinType::PseudoObject:
- case BuiltinType::BuiltinFn:
- case BuiltinType::OCLEvent:
- case BuiltinType::OCLImage1d:
- case BuiltinType::OCLImage1dArray:
- case BuiltinType::OCLImage1dBuffer:
- case BuiltinType::OCLImage2d:
- case BuiltinType::OCLImage2dArray:
- case BuiltinType::OCLImage3d:
- case BuiltinType::OCLSampler:
+ 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:
+ case clang::BuiltinType::BuiltinFn:
+ case clang::BuiltinType::OCLEvent:
+ case clang::BuiltinType::OCLImage1d:
+ case clang::BuiltinType::OCLImage1dArray:
+ case clang::BuiltinType::OCLImage1dBuffer:
+ case clang::BuiltinType::OCLImage2d:
+ case clang::BuiltinType::OCLImage2dArray:
+ case clang::BuiltinType::OCLImage3d:
+ case clang::BuiltinType::OCLSampler:
return lldb::eFormatHex;
}
break;
@@ -2023,13 +2135,13 @@ ClangASTType::GetFormat () const
case clang::Type::Record: break;
case clang::Type::Enum: return lldb::eFormatEnum;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat();
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat();
case clang::Type::Auto:
- return ClangASTType (m_ast, cast<AutoType>(qual_type)->desugar()).GetFormat();
+ return ClangASTType (m_ast, llvm::cast<clang::AutoType>(qual_type)->desugar()).GetFormat();
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetFormat();
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetFormat();
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetFormat();
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetFormat();
case clang::Type::DependentSizedArray:
case clang::Type::DependentSizedExtVector:
case clang::Type::UnresolvedUsing:
@@ -2048,6 +2160,7 @@ ClangASTType::GetFormat () const
case clang::Type::Decltype:
case clang::Type::TemplateSpecialization:
case clang::Type::Atomic:
+ case clang::Type::Adjusted:
break;
// pointer type decayed from an array or function type.
@@ -2059,7 +2172,7 @@ ClangASTType::GetFormat () const
}
static bool
-ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
+ObjCDeclHasIVars (clang::ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
{
while (class_interface_decl)
{
@@ -2081,15 +2194,15 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
return 0;
uint32_t num_children = 0;
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
- switch (cast<BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
- case BuiltinType::ObjCId: // child is Class
- case BuiltinType::ObjCClass: // child is Class
+ case clang::BuiltinType::ObjCId: // child is Class
+ case clang::BuiltinType::ObjCClass: // child is Class
num_children = 1;
break;
@@ -2103,10 +2216,10 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::Record:
if (GetCompleteQualType (m_ast, qual_type))
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
+ const clang::RecordDecl *record_decl = record_type->getDecl();
assert(record_decl);
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
if (cxx_record_decl)
{
if (omit_empty_base_classes)
@@ -2115,12 +2228,12 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
// base classes contain any fields. This can help
// limit the noise in variable views by not having to
// show base classes that contain no members.
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
// Skip empty base classes
if (ClangASTContext::RecordHasFields(base_class_decl) == false)
@@ -2136,7 +2249,7 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
}
}
- RecordDecl::field_iterator field, field_end;
+ clang::RecordDecl::field_iterator field, field_end;
for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
++num_children;
}
@@ -2146,16 +2259,16 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::ObjCInterface:
if (GetCompleteQualType (m_ast, qual_type))
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
if (superclass_interface_decl)
{
if (omit_empty_base_classes)
@@ -2175,8 +2288,8 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::ObjCObjectPointer:
{
- const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
- QualType pointee_type = pointer_type->getPointeeType();
+ const clang::ObjCObjectPointerType *pointer_type = llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr());
+ clang::QualType pointee_type = pointer_type->getPointeeType();
uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
// If this type points to a simple type, then it has 1 child
if (num_pointee_children == 0)
@@ -2188,17 +2301,17 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::Vector:
case clang::Type::ExtVector:
- num_children = cast<VectorType>(qual_type.getTypePtr())->getNumElements();
+ num_children = llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
break;
case clang::Type::ConstantArray:
- num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
+ num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
break;
case clang::Type::Pointer:
{
- const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
- QualType pointee_type (pointer_type->getPointeeType());
+ const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
+ clang::QualType pointee_type (pointer_type->getPointeeType());
uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
if (num_pointee_children == 0)
{
@@ -2214,8 +2327,8 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::LValueReference:
case clang::Type::RValueReference:
{
- const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
- QualType pointee_type = reference_type->getPointeeType();
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
+ clang::QualType pointee_type = reference_type->getPointeeType();
uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes);
// If this type points to a simple type, then it has 1 child
if (num_pointee_children == 0)
@@ -2227,15 +2340,15 @@ ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
case clang::Type::Typedef:
- num_children = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes);
+ num_children = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes);
break;
case clang::Type::Elaborated:
- num_children = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes);
+ num_children = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes);
break;
case clang::Type::Paren:
- num_children = ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes);
+ num_children = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes);
break;
default:
break;
@@ -2248,11 +2361,11 @@ ClangASTType::GetBasicTypeEnumeration () const
{
if (IsValid())
{
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
if (type_class == clang::Type::Builtin)
{
- switch (cast<clang::BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
case clang::BuiltinType::Void: return eBasicTypeVoid;
case clang::BuiltinType::Bool: return eBasicTypeBool;
@@ -2316,14 +2429,14 @@ ClangASTType::GetNumDirectBaseClasses () const
return 0;
uint32_t count = 0;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
count = cxx_record_decl->getNumBases();
}
@@ -2336,10 +2449,10 @@ ClangASTType::GetNumDirectBaseClasses () const
case clang::Type::ObjCObject:
if (GetCompleteType())
{
- const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
+ const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl && class_interface_decl->getSuperClass())
count = 1;
@@ -2349,10 +2462,10 @@ ClangASTType::GetNumDirectBaseClasses () const
case clang::Type::ObjCInterface:
if (GetCompleteType())
{
- const ObjCInterfaceType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>();
+ const clang::ObjCInterfaceType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
if (objc_interface_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
if (class_interface_decl && class_interface_decl->getSuperClass())
count = 1;
@@ -2362,15 +2475,15 @@ ClangASTType::GetNumDirectBaseClasses () const
case clang::Type::Typedef:
- count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses ();
+ count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses ();
break;
case clang::Type::Elaborated:
- count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses ();
+ count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses ();
break;
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses ();
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses ();
default:
break;
@@ -2385,29 +2498,29 @@ ClangASTType::GetNumVirtualBaseClasses () const
return 0;
uint32_t count = 0;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
count = cxx_record_decl->getNumVBases();
}
break;
case clang::Type::Typedef:
- count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses();
+ count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses();
break;
case clang::Type::Elaborated:
- count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses();
+ count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses();
break;
case clang::Type::Paren:
- count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses();
+ count = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses();
break;
default:
@@ -2423,21 +2536,21 @@ ClangASTType::GetNumFields () const
return 0;
uint32_t count = 0;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
+ const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
if (record_type)
{
- RecordDecl *record_decl = record_type->getDecl();
+ clang::RecordDecl *record_decl = record_type->getDecl();
if (record_decl)
{
uint32_t field_idx = 0;
- RecordDecl::field_iterator field, field_end;
+ 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;
count = field_idx;
@@ -2447,24 +2560,24 @@ ClangASTType::GetNumFields () const
break;
case clang::Type::Typedef:
- count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields();
+ count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields();
break;
case clang::Type::Elaborated:
- count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumFields();
+ count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumFields();
break;
case clang::Type::Paren:
- count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumFields();
+ count = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumFields();
break;
case clang::Type::ObjCObjectPointer:
if (GetCompleteType())
{
- const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
+ const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
if (class_interface_decl)
count = class_interface_decl->ivar_size();
@@ -2476,10 +2589,10 @@ ClangASTType::GetNumFields () const
case clang::Type::ObjCInterface:
if (GetCompleteType())
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
count = class_interface_decl->ivar_size();
@@ -2499,18 +2612,18 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c
if (!IsValid())
return ClangASTType();
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
uint32_t curr_idx = 0;
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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, ++curr_idx)
@@ -2519,8 +2632,8 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c
{
if (bit_offset_ptr)
{
- const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
- const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
+ const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
if (base_class->isVirtual())
*bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
else
@@ -2539,14 +2652,14 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c
case clang::Type::ObjCObject:
if (idx == 0 && GetCompleteType())
{
- const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
+ const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
if (superclass_interface_decl)
{
if (bit_offset_ptr)
@@ -2560,14 +2673,14 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c
case clang::Type::ObjCInterface:
if (idx == 0 && GetCompleteType())
{
- const ObjCObjectType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>();
+ const clang::ObjCObjectType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
if (objc_interface_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
if (class_interface_decl)
{
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
if (superclass_interface_decl)
{
if (bit_offset_ptr)
@@ -2581,13 +2694,13 @@ ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) c
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
default:
break;
@@ -2601,18 +2714,18 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr)
if (!IsValid())
return ClangASTType();
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
uint32_t curr_idx = 0;
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end();
base_class != base_class_end;
++base_class, ++curr_idx)
@@ -2621,8 +2734,8 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr)
{
if (bit_offset_ptr)
{
- const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
- const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
+ const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
*bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
}
@@ -2634,13 +2747,13 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr)
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
default:
break;
@@ -2650,7 +2763,7 @@ ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr)
static clang_type_t
GetObjCFieldAtIndex (clang::ASTContext *ast,
- ObjCInterfaceDecl *class_interface_decl,
+ clang::ObjCInterfaceDecl *class_interface_decl,
size_t idx,
std::string& name,
uint64_t *bit_offset_ptr,
@@ -2661,22 +2774,22 @@ GetObjCFieldAtIndex (clang::ASTContext *ast,
{
if (idx < (class_interface_decl->ivar_size()))
{
- ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
+ clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
uint32_t ivar_idx = 0;
for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx)
{
if (ivar_idx == idx)
{
- const ObjCIvarDecl* ivar_decl = *ivar_pos;
+ const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
- QualType ivar_qual_type(ivar_decl->getType());
+ clang::QualType ivar_qual_type(ivar_decl->getType());
name.assign(ivar_decl->getNameAsString());
if (bit_offset_ptr)
{
- const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
+ const clang::ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
*bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx);
}
@@ -2688,7 +2801,7 @@ GetObjCFieldAtIndex (clang::ASTContext *ast,
if (is_bitfield && ast)
{
- Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
+ clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
llvm::APSInt bitfield_apsint;
if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast))
{
@@ -2704,7 +2817,7 @@ GetObjCFieldAtIndex (clang::ASTContext *ast,
}
}
}
- return NULL;
+ return nullptr;
}
ClangASTType
@@ -2717,17 +2830,17 @@ ClangASTType::GetFieldAtIndex (size_t idx,
if (!IsValid())
return ClangASTType();
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType())
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
+ const clang::RecordDecl *record_decl = record_type->getDecl();
uint32_t field_idx = 0;
- RecordDecl::field_iterator field, field_end;
+ 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)
{
if (idx == field_idx)
@@ -2740,7 +2853,7 @@ ClangASTType::GetFieldAtIndex (size_t idx,
// alignment (field_type_info.second) from the AST context.
if (bit_offset_ptr)
{
- const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
+ const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
*bit_offset_ptr = record_layout.getFieldOffset (field_idx);
}
@@ -2752,7 +2865,7 @@ ClangASTType::GetFieldAtIndex (size_t idx,
if (is_bitfield)
{
- Expr *bitfield_bit_size_expr = field->getBitWidth();
+ clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
llvm::APSInt bitfield_apsint;
if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast))
{
@@ -2772,10 +2885,10 @@ ClangASTType::GetFieldAtIndex (size_t idx,
case clang::Type::ObjCObjectPointer:
if (GetCompleteType())
{
- const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
+ const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
}
}
@@ -2785,11 +2898,11 @@ ClangASTType::GetFieldAtIndex (size_t idx,
case clang::Type::ObjCInterface:
if (GetCompleteType())
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
}
}
@@ -2797,7 +2910,7 @@ ClangASTType::GetFieldAtIndex (size_t idx,
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).
GetFieldAtIndex (idx,
name,
bit_offset_ptr,
@@ -2805,7 +2918,7 @@ ClangASTType::GetFieldAtIndex (size_t idx,
is_bitfield_ptr);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).
GetFieldAtIndex (idx,
name,
bit_offset_ptr,
@@ -2813,7 +2926,7 @@ ClangASTType::GetFieldAtIndex (size_t idx,
is_bitfield_ptr);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).
GetFieldAtIndex (idx,
name,
bit_offset_ptr,
@@ -2859,12 +2972,12 @@ ClangASTType::GetNumPointeeChildren () const
if (!IsValid())
return 0;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Builtin:
- switch (cast<clang::BuiltinType>(qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
{
case clang::BuiltinType::UnknownAny:
case clang::BuiltinType::Void:
@@ -2930,9 +3043,9 @@ ClangASTType::GetNumPointeeChildren () const
case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children...
case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children...
case clang::Type::UnresolvedUsing: return 0;
- case clang::Type::Paren: return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren ();
- case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren ();
- case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren ();
+ case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren ();
+ case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren ();
+ case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren ();
case clang::Type::TypeOfExpr: return 0;
case clang::Type::TypeOf: return 0;
case clang::Type::Decltype: return 0;
@@ -2956,7 +3069,6 @@ ClangASTType::GetNumPointeeChildren () const
ClangASTType
ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
- const char *parent_name,
size_t idx,
bool transparent_pointers,
bool omit_empty_base_classes,
@@ -2967,12 +3079,13 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
uint32_t &child_bitfield_bit_size,
uint32_t &child_bitfield_bit_offset,
bool &child_is_base_class,
- bool &child_is_deref_of_parent) const
+ bool &child_is_deref_of_parent,
+ ValueObject *valobj) const
{
if (!IsValid())
return ClangASTType();
- QualType parent_qual_type(GetCanonicalQualType());
+ clang::QualType parent_qual_type(GetCanonicalQualType());
const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
child_bitfield_bit_size = 0;
child_bitfield_bit_offset = 0;
@@ -2985,7 +3098,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::Builtin:
if (idx_is_valid)
{
- switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
+ switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind())
{
case clang::BuiltinType::ObjCId:
case clang::BuiltinType::ObjCClass:
@@ -3002,39 +3115,106 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::Record:
if (idx_is_valid && GetCompleteType())
{
- const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ const clang::RecordType *record_type = llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
+ const clang::RecordDecl *record_decl = record_type->getDecl();
assert(record_decl);
- const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
+ const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
uint32_t child_idx = 0;
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ 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
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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 CXXRecordDecl *base_class_decl = NULL;
+ const clang::CXXRecordDecl *base_class_decl = nullptr;
// Skip empty base classes
if (omit_empty_base_classes)
{
- base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
if (ClangASTContext::RecordHasFields(base_class_decl) == false)
continue;
}
if (idx == child_idx)
{
- if (base_class_decl == NULL)
- base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ if (base_class_decl == nullptr)
+ base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
if (base_class->isVirtual())
- bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
+ {
+ bool handled = false;
+ if (valobj)
+ {
+ Error err;
+ AddressType addr_type = eAddressTypeInvalid;
+ lldb::addr_t vtable_ptr_addr = valobj->GetCPPVTableAddress(addr_type);
+
+ if (vtable_ptr_addr != LLDB_INVALID_ADDRESS && addr_type == eAddressTypeLoad)
+ {
+
+ ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
+ Process *process = exe_ctx.GetProcessPtr();
+ if (process)
+ {
+ clang::VTableContextBase *vtable_ctx = m_ast->getVTableContext();
+ if (vtable_ctx)
+ {
+ if (vtable_ctx->isMicrosoft())
+ {
+ clang::MicrosoftVTableContext *msoft_vtable_ctx = static_cast<clang::MicrosoftVTableContext *>(vtable_ctx);
+
+ if (vtable_ptr_addr)
+ {
+ const lldb::addr_t vbtable_ptr_addr = vtable_ptr_addr + record_layout.getVBPtrOffset().getQuantity();
+
+ const lldb::addr_t vbtable_ptr = process->ReadPointerFromMemory(vbtable_ptr_addr, err);
+ if (vbtable_ptr != LLDB_INVALID_ADDRESS)
+ {
+ // Get the index into the virtual base table. The index is the index in uint32_t from vbtable_ptr
+ const unsigned vbtable_index = msoft_vtable_ctx->getVBTableIndex(cxx_record_decl, base_class_decl);
+ const lldb::addr_t base_offset_addr = vbtable_ptr + vbtable_index * 4;
+ const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX, err);
+ if (base_offset != UINT32_MAX)
+ {
+ handled = true;
+ bit_offset = base_offset * 8;
+ }
+ }
+ }
+ }
+ else
+ {
+ clang::ItaniumVTableContext *itanium_vtable_ctx = static_cast<clang::ItaniumVTableContext *>(vtable_ctx);
+ if (vtable_ptr_addr)
+ {
+ const lldb::addr_t vtable_ptr = process->ReadPointerFromMemory(vtable_ptr_addr, err);
+ if (vtable_ptr != LLDB_INVALID_ADDRESS)
+ {
+ clang::CharUnits base_offset_offset = itanium_vtable_ctx->getVirtualBaseOffsetOffset(cxx_record_decl, base_class_decl);
+ const lldb::addr_t base_offset_addr = vtable_ptr + base_offset_offset.getQuantity();
+ const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX, err);
+ if (base_offset != UINT32_MAX)
+ {
+ handled = true;
+ bit_offset = base_offset * 8;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ }
+ if (!handled)
+ bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
+ }
else
bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
@@ -3057,7 +3237,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
}
// Make sure index is in range...
uint32_t field_idx = 0;
- RecordDecl::field_iterator field, field_end;
+ 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)
{
if (idx == child_idx)
@@ -3088,18 +3268,18 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::ObjCInterface:
if (idx_is_valid && GetCompleteType())
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
uint32_t child_idx = 0;
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- const ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl);
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ const clang::ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl);
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
if (superclass_interface_decl)
{
if (omit_empty_base_classes)
@@ -3109,14 +3289,14 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
{
if (idx == 0)
{
- QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl));
+ clang::QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl));
child_name.assign(superclass_interface_decl->getNameAsString().c_str());
- std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
+ clang::TypeInfo ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
- child_byte_size = ivar_type_info.first / 8;
+ child_byte_size = ivar_type_info.Width / 8;
child_byte_offset = 0;
child_is_base_class = true;
@@ -3134,21 +3314,21 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
if (idx < (child_idx + class_interface_decl->ivar_size()))
{
- ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
+ clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
{
if (child_idx == idx)
{
- ObjCIvarDecl* ivar_decl = *ivar_pos;
+ clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
- QualType ivar_qual_type(ivar_decl->getType());
+ clang::QualType ivar_qual_type(ivar_decl->getType());
child_name.assign(ivar_decl->getNameAsString().c_str());
- std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
+ clang::TypeInfo ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
- child_byte_size = ivar_type_info.first / 8;
+ child_byte_size = ivar_type_info.Width / 8;
// Figure out the field offset within the current struct/union/class type
// For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
@@ -3156,13 +3336,13 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
// the changing size of base classes that are newer than this class.
// So if we have a process around that we can ask about this object, do so.
child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
- Process *process = NULL;
+ Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process)
{
ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
- if (objc_runtime != NULL)
+ if (objc_runtime != nullptr)
{
ClangASTType parent_ast_type (m_ast, parent_qual_type);
child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
@@ -3172,7 +3352,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
// Setting this to UINT32_MAX to make sure we don't compute it twice...
bit_offset = UINT32_MAX;
- if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET)
+ if (child_byte_offset == static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET))
{
bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
child_byte_offset = bit_offset / 8;
@@ -3209,7 +3389,6 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_is_deref_of_parent = false;
bool tmp_child_is_deref_of_parent = false;
return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3220,11 +3399,13 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- tmp_child_is_deref_of_parent);
+ tmp_child_is_deref_of_parent,
+ valobj);
}
else
{
child_is_deref_of_parent = true;
+ const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
if (parent_name)
{
child_name.assign(1, '*');
@@ -3246,7 +3427,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::ExtVector:
if (idx_is_valid)
{
- const VectorType *array = cast<VectorType>(parent_qual_type.getTypePtr());
+ const clang::VectorType *array = llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
if (array)
{
ClangASTType element_type (m_ast, array->getElementType());
@@ -3267,7 +3448,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::IncompleteArray:
if (ignore_array_bounds || idx_is_valid)
{
- const ArrayType *array = cast<ArrayType>(parent_qual_type.getTypePtr());
+ const clang::ArrayType *array = llvm::cast<clang::ArrayType>(parent_qual_type.getTypePtr());
if (array)
{
ClangASTType element_type (m_ast, array->getElementType());
@@ -3299,7 +3480,6 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_is_deref_of_parent = false;
bool tmp_child_is_deref_of_parent = false;
return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3310,12 +3490,14 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- tmp_child_is_deref_of_parent);
+ tmp_child_is_deref_of_parent,
+ valobj);
}
else
{
child_is_deref_of_parent = true;
+ const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
if (parent_name)
{
child_name.assign(1, '*');
@@ -3337,14 +3519,13 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::RValueReference:
if (idx_is_valid)
{
- const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType());
if (transparent_pointers && pointee_clang_type.IsAggregateType ())
{
child_is_deref_of_parent = false;
bool tmp_child_is_deref_of_parent = false;
return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3355,10 +3536,12 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- tmp_child_is_deref_of_parent);
+ tmp_child_is_deref_of_parent,
+ valobj);
}
else
{
+ const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
if (parent_name)
{
child_name.assign(1, '&');
@@ -3378,9 +3561,8 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
case clang::Type::Typedef:
{
- ClangASTType typedefed_clang_type (m_ast, cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType());
+ ClangASTType typedefed_clang_type (m_ast, llvm::cast<clang::TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType());
return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3391,15 +3573,15 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- child_is_deref_of_parent);
+ child_is_deref_of_parent,
+ valobj);
}
break;
case clang::Type::Elaborated:
{
- ClangASTType elaborated_clang_type (m_ast, cast<ElaboratedType>(parent_qual_type)->getNamedType());
+ ClangASTType elaborated_clang_type (m_ast, llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType());
return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3410,14 +3592,14 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- child_is_deref_of_parent);
+ child_is_deref_of_parent,
+ valobj);
}
case clang::Type::Paren:
{
ClangASTType paren_clang_type (m_ast, llvm::cast<clang::ParenType>(parent_qual_type)->desugar());
return paren_clang_type.GetChildClangTypeAtIndex (exe_ctx,
- parent_name,
idx,
transparent_pointers,
omit_empty_base_classes,
@@ -3428,7 +3610,8 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class,
- child_is_deref_of_parent);
+ child_is_deref_of_parent,
+ valobj);
}
@@ -3439,7 +3622,7 @@ ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
}
static inline bool
-BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
+BaseSpecifierIsEmpty (const clang::CXXBaseSpecifier *b)
{
return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
}
@@ -3447,22 +3630,22 @@ BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
static uint32_t
GetIndexForRecordBase
(
- const RecordDecl *record_decl,
- const CXXBaseSpecifier *base_spec,
+ const clang::RecordDecl *record_decl,
+ const clang::CXXBaseSpecifier *base_spec,
bool omit_empty_base_classes
)
{
uint32_t child_idx = 0;
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
// const char *super_name = record_decl->getNameAsCString();
- // const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
+ // const char *base_name = base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString();
// printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
//
if (cxx_record_decl)
{
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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)
@@ -3475,7 +3658,7 @@ GetIndexForRecordBase
// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
// child_idx,
- // base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
+ // base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString());
//
//
if (base_class == base_spec)
@@ -3489,14 +3672,14 @@ GetIndexForRecordBase
static uint32_t
-GetIndexForRecordChild (const RecordDecl *record_decl,
- NamedDecl *canonical_decl,
+GetIndexForRecordChild (const clang::RecordDecl *record_decl,
+ clang::NamedDecl *canonical_decl,
bool omit_empty_base_classes)
{
- uint32_t child_idx = ClangASTContext::GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl),
+ uint32_t child_idx = ClangASTContext::GetNumBaseClasses (llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
omit_empty_base_classes);
- RecordDecl::field_iterator field, field_end;
+ clang::RecordDecl::field_iterator field, field_end;
for (field = record_decl->field_begin(), field_end = record_decl->field_end();
field != field_end;
++field, ++child_idx)
@@ -3549,24 +3732,24 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
{
if (IsValid() && name && name[0])
{
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
if (GetCompleteType ())
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ 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 child_idx = 0;
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
// Try and find a field that matches NAME
- RecordDecl::field_iterator field, field_end;
- StringRef name_sref(name);
+ clang::RecordDecl::field_iterator field, field_end;
+ llvm::StringRef name_sref(name);
for (field = record_decl->field_begin(), field_end = record_decl->field_end();
field != field_end;
++field, ++child_idx)
@@ -3591,27 +3774,27 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
if (cxx_record_decl)
{
- const RecordDecl *parent_record_decl = cxx_record_decl;
+ const clang::RecordDecl *parent_record_decl = cxx_record_decl;
//printf ("parent = %s\n", parent_record_decl->getNameAsCString());
//const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
// Didn't find things easily, lets let clang do its thang...
- IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref);
- DeclarationName decl_name(&ident_ref);
+ clang::IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref);
+ clang::DeclarationName decl_name(&ident_ref);
- CXXBasePaths paths;
- if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
+ clang::CXXBasePaths paths;
+ if (cxx_record_decl->lookupInBases(clang::CXXRecordDecl::FindOrdinaryMember,
decl_name.getAsOpaquePtr(),
paths))
{
- CXXBasePaths::const_paths_iterator path, path_end = paths.end();
+ clang::CXXBasePaths::const_paths_iterator path, path_end = paths.end();
for (path = paths.begin(); path != path_end; ++path)
{
const size_t num_path_elements = path->size();
for (size_t e=0; e<num_path_elements; ++e)
{
- CXXBasePathElement elem = (*path)[e];
+ clang::CXXBasePathElement elem = (*path)[e];
child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
if (child_idx == UINT32_MAX)
@@ -3622,10 +3805,10 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
else
{
child_indexes.push_back (child_idx);
- parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
+ parent_record_decl = llvm::cast<clang::RecordDecl>(elem.Base->getType()->getAs<clang::RecordType>()->getDecl());
}
}
- for (NamedDecl *path_decl : path->Decls)
+ for (clang::NamedDecl *path_decl : path->Decls)
{
child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes);
if (child_idx == UINT32_MAX)
@@ -3650,22 +3833,22 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
case clang::Type::ObjCInterface:
if (GetCompleteType ())
{
- StringRef name_sref(name);
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ llvm::StringRef name_sref(name);
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
uint32_t child_idx = 0;
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
{
- const ObjCIvarDecl* ivar_decl = *ivar_pos;
+ const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
if (ivar_decl->getName().equals (name_sref))
{
@@ -3707,7 +3890,7 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
case clang::Type::ObjCObjectPointer:
{
- ClangASTType objc_object_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
+ ClangASTType objc_object_clang_type (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
return objc_object_clang_type.GetIndexOfChildMemberWithName (name,
omit_empty_base_classes,
child_indexes);
@@ -3717,7 +3900,7 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
case clang::Type::ConstantArray:
{
- // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
+ // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
// const uint64_t element_count = array->getSize().getLimitedValue();
//
// if (idx < element_count)
@@ -3738,8 +3921,8 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
// case clang::Type::MemberPointerType:
// {
- // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
- // QualType pointee_type = mem_ptr_type->getPointeeType();
+ // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
+ // clang::QualType pointee_type = mem_ptr_type->getPointeeType();
//
// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
// {
@@ -3753,8 +3936,8 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
case clang::Type::LValueReference:
case clang::Type::RValueReference:
{
- const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
- QualType pointee_type(reference_type->getPointeeType());
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
+ clang::QualType pointee_type(reference_type->getPointeeType());
ClangASTType pointee_clang_type (m_ast, pointee_type);
if (pointee_clang_type.IsAggregateType ())
@@ -3780,17 +3963,17 @@ ClangASTType::GetIndexOfChildMemberWithName (const char *name,
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name,
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name,
omit_empty_base_classes,
child_indexes);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name,
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name,
omit_empty_base_classes,
child_indexes);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name,
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name,
omit_empty_base_classes,
child_indexes);
@@ -3811,7 +3994,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
{
if (IsValid() && name && name[0])
{
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
@@ -3820,23 +4003,23 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
case clang::Type::Record:
if (GetCompleteType ())
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ 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 child_idx = 0;
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
if (cxx_record_decl)
{
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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)
{
// Skip empty base classes
- CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false)
continue;
@@ -3849,8 +4032,8 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
}
// Try and find a field that matches NAME
- RecordDecl::field_iterator field, field_end;
- StringRef name_sref(name);
+ clang::RecordDecl::field_iterator field, field_end;
+ llvm::StringRef name_sref(name);
for (field = record_decl->field_begin(), field_end = record_decl->field_end();
field != field_end;
++field, ++child_idx)
@@ -3866,22 +4049,22 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
case clang::Type::ObjCInterface:
if (GetCompleteType())
{
- StringRef name_sref(name);
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ llvm::StringRef name_sref(name);
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
uint32_t child_idx = 0;
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
- ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
+ clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
+ clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
{
- const ObjCIvarDecl* ivar_decl = *ivar_pos;
+ const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
if (ivar_decl->getName().equals (name_sref))
{
@@ -3905,14 +4088,14 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
case clang::Type::ObjCObjectPointer:
{
- ClangASTType pointee_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
+ ClangASTType pointee_clang_type (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
}
break;
case clang::Type::ConstantArray:
{
- // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
+ // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
// const uint64_t element_count = array->getSize().getLimitedValue();
//
// if (idx < element_count)
@@ -3933,8 +4116,8 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
// case clang::Type::MemberPointerType:
// {
- // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
- // QualType pointee_type = mem_ptr_type->getPointeeType();
+ // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
+ // clang::QualType pointee_type = mem_ptr_type->getPointeeType();
//
// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
// {
@@ -3948,7 +4131,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
case clang::Type::LValueReference:
case clang::Type::RValueReference:
{
- const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+ const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
ClangASTType pointee_type (m_ast, reference_type->getPointeeType());
if (pointee_type.IsAggregateType ())
@@ -3960,7 +4143,7 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
case clang::Type::Pointer:
{
- const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
+ const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
ClangASTType pointee_type (m_ast, pointer_type->getPointeeType());
if (pointee_type.IsAggregateType ())
@@ -3989,13 +4172,13 @@ ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_cl
break;
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes);
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
default:
break;
@@ -4010,7 +4193,7 @@ ClangASTType::GetNumTemplateArguments () const
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -4018,10 +4201,10 @@ ClangASTType::GetNumTemplateArguments () const
case clang::Type::Record:
if (GetCompleteType ())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
- const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
+ const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
if (template_decl)
return template_decl->getTemplateArgs().size();
}
@@ -4029,13 +4212,13 @@ ClangASTType::GetNumTemplateArguments () const
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments();
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments();
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments();
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments();
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumTemplateArguments();
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumTemplateArguments();
default:
break;
@@ -4049,7 +4232,7 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -4057,13 +4240,13 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k
case clang::Type::Record:
if (GetCompleteType ())
{
- const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
- const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
+ const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
if (template_decl && arg_idx < template_decl->getTemplateArgs().size())
{
- const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
+ const clang::TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
switch (template_arg.getKind())
{
case clang::TemplateArgument::Null:
@@ -4099,7 +4282,7 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k
return ClangASTType();
default:
- assert (!"Unhandled TemplateArgument::ArgKind");
+ assert (!"Unhandled clang::TemplateArgument::ArgKind");
break;
}
}
@@ -4108,13 +4291,13 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind);
default:
break;
@@ -4125,15 +4308,15 @@ ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &k
}
static bool
-IsOperator (const char *name, OverloadedOperatorKind &op_kind)
+IsOperator (const char *name, clang::OverloadedOperatorKind &op_kind)
{
- if (name == NULL || name[0] == '\0')
+ if (name == nullptr || name[0] == '\0')
return false;
#define OPERATOR_PREFIX "operator"
#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
- const char *post_op_name = NULL;
+ const char *post_op_name = nullptr;
bool no_space = true;
@@ -4153,7 +4336,7 @@ IsOperator (const char *name, OverloadedOperatorKind &op_kind)
// This is an operator, set the overloaded operator kind to invalid
// in case this is a conversion operator...
- op_kind = NUM_OVERLOADED_OPERATORS;
+ op_kind = clang::NUM_OVERLOADED_OPERATORS;
switch (post_op_name[0])
{
@@ -4165,204 +4348,197 @@ IsOperator (const char *name, OverloadedOperatorKind &op_kind)
if (no_space)
return false;
if (strcmp (post_op_name, "new") == 0)
- op_kind = OO_New;
+ op_kind = clang::OO_New;
else if (strcmp (post_op_name, "new[]") == 0)
- op_kind = OO_Array_New;
+ op_kind = clang::OO_Array_New;
break;
case 'd':
if (no_space)
return false;
if (strcmp (post_op_name, "delete") == 0)
- op_kind = OO_Delete;
+ op_kind = clang::OO_Delete;
else if (strcmp (post_op_name, "delete[]") == 0)
- op_kind = OO_Array_Delete;
+ op_kind = clang::OO_Array_Delete;
break;
case '+':
if (post_op_name[1] == '\0')
- op_kind = OO_Plus;
+ op_kind = clang::OO_Plus;
else if (post_op_name[2] == '\0')
{
if (post_op_name[1] == '=')
- op_kind = OO_PlusEqual;
+ op_kind = clang::OO_PlusEqual;
else if (post_op_name[1] == '+')
- op_kind = OO_PlusPlus;
+ op_kind = clang::OO_PlusPlus;
}
break;
case '-':
if (post_op_name[1] == '\0')
- op_kind = OO_Minus;
+ op_kind = clang::OO_Minus;
else if (post_op_name[2] == '\0')
{
switch (post_op_name[1])
{
- case '=': op_kind = OO_MinusEqual; break;
- case '-': op_kind = OO_MinusMinus; break;
- case '>': op_kind = OO_Arrow; break;
+ case '=': op_kind = clang::OO_MinusEqual; break;
+ case '-': op_kind = clang::OO_MinusMinus; break;
+ case '>': op_kind = clang::OO_Arrow; break;
}
}
else if (post_op_name[3] == '\0')
{
if (post_op_name[2] == '*')
- op_kind = OO_ArrowStar; break;
+ op_kind = clang::OO_ArrowStar; break;
}
break;
case '*':
if (post_op_name[1] == '\0')
- op_kind = OO_Star;
+ op_kind = clang::OO_Star;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_StarEqual;
+ op_kind = clang::OO_StarEqual;
break;
case '/':
if (post_op_name[1] == '\0')
- op_kind = OO_Slash;
+ op_kind = clang::OO_Slash;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_SlashEqual;
+ op_kind = clang::OO_SlashEqual;
break;
case '%':
if (post_op_name[1] == '\0')
- op_kind = OO_Percent;
+ op_kind = clang::OO_Percent;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_PercentEqual;
+ op_kind = clang::OO_PercentEqual;
break;
case '^':
if (post_op_name[1] == '\0')
- op_kind = OO_Caret;
+ op_kind = clang::OO_Caret;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_CaretEqual;
+ op_kind = clang::OO_CaretEqual;
break;
case '&':
if (post_op_name[1] == '\0')
- op_kind = OO_Amp;
+ op_kind = clang::OO_Amp;
else if (post_op_name[2] == '\0')
{
switch (post_op_name[1])
{
- case '=': op_kind = OO_AmpEqual; break;
- case '&': op_kind = OO_AmpAmp; break;
+ case '=': op_kind = clang::OO_AmpEqual; break;
+ case '&': op_kind = clang::OO_AmpAmp; break;
}
}
break;
case '|':
if (post_op_name[1] == '\0')
- op_kind = OO_Pipe;
+ op_kind = clang::OO_Pipe;
else if (post_op_name[2] == '\0')
{
switch (post_op_name[1])
{
- case '=': op_kind = OO_PipeEqual; break;
- case '|': op_kind = OO_PipePipe; break;
+ case '=': op_kind = clang::OO_PipeEqual; break;
+ case '|': op_kind = clang::OO_PipePipe; break;
}
}
break;
case '~':
if (post_op_name[1] == '\0')
- op_kind = OO_Tilde;
+ op_kind = clang::OO_Tilde;
break;
case '!':
if (post_op_name[1] == '\0')
- op_kind = OO_Exclaim;
+ op_kind = clang::OO_Exclaim;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_ExclaimEqual;
+ op_kind = clang::OO_ExclaimEqual;
break;
case '=':
if (post_op_name[1] == '\0')
- op_kind = OO_Equal;
+ op_kind = clang::OO_Equal;
else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
- op_kind = OO_EqualEqual;
+ op_kind = clang::OO_EqualEqual;
break;
case '<':
if (post_op_name[1] == '\0')
- op_kind = OO_Less;
+ op_kind = clang::OO_Less;
else if (post_op_name[2] == '\0')
{
switch (post_op_name[1])
{
- case '<': op_kind = OO_LessLess; break;
- case '=': op_kind = OO_LessEqual; break;
+ case '<': op_kind = clang::OO_LessLess; break;
+ case '=': op_kind = clang::OO_LessEqual; break;
}
}
else if (post_op_name[3] == '\0')
{
if (post_op_name[2] == '=')
- op_kind = OO_LessLessEqual;
+ op_kind = clang::OO_LessLessEqual;
}
break;
case '>':
if (post_op_name[1] == '\0')
- op_kind = OO_Greater;
+ op_kind = clang::OO_Greater;
else if (post_op_name[2] == '\0')
{
switch (post_op_name[1])
{
- case '>': op_kind = OO_GreaterGreater; break;
- case '=': op_kind = OO_GreaterEqual; break;
+ case '>': op_kind = clang::OO_GreaterGreater; break;
+ case '=': op_kind = clang::OO_GreaterEqual; break;
}
}
else if (post_op_name[1] == '>' &&
post_op_name[2] == '=' &&
post_op_name[3] == '\0')
{
- op_kind = OO_GreaterGreaterEqual;
+ op_kind = clang::OO_GreaterGreaterEqual;
}
break;
case ',':
if (post_op_name[1] == '\0')
- op_kind = OO_Comma;
+ op_kind = clang::OO_Comma;
break;
case '(':
if (post_op_name[1] == ')' && post_op_name[2] == '\0')
- op_kind = OO_Call;
+ op_kind = clang::OO_Call;
break;
case '[':
if (post_op_name[1] == ']' && post_op_name[2] == '\0')
- op_kind = OO_Subscript;
+ op_kind = clang::OO_Subscript;
break;
}
return true;
}
-static inline bool
-check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
+clang::EnumDecl *
+ClangASTType::GetAsEnumDecl () const
{
- // Special-case call since it can take any number of operands
- if(op_kind == OO_Call)
- return true;
-
- // The parameter count doens't include "this"
- if (num_params == 0)
- return unary;
- if (num_params == 1)
- return binary;
- else
- return false;
+ const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType());
+ if (enum_type)
+ return enum_type->getDecl();
+ return NULL;
}
clang::RecordDecl *
ClangASTType::GetAsRecordDecl () const
{
- const RecordType *record_type = dyn_cast<RecordType>(GetCanonicalQualType());
+ const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(GetCanonicalQualType());
if (record_type)
return record_type->getDecl();
- return NULL;
+ return nullptr;
}
clang::CXXRecordDecl *
@@ -4371,13 +4547,13 @@ ClangASTType::GetAsCXXRecordDecl () const
return GetCanonicalQualType()->getAsCXXRecordDecl();
}
-ObjCInterfaceDecl *
+clang::ObjCInterfaceDecl *
ClangASTType::GetAsObjCInterfaceDecl () const
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(GetCanonicalQualType());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(GetCanonicalQualType());
if (objc_class_type)
return objc_class_type->getInterface();
- return NULL;
+ return nullptr;
}
clang::FieldDecl *
@@ -4387,37 +4563,37 @@ ClangASTType::AddFieldToRecordType (const char *name,
uint32_t bitfield_bit_size)
{
if (!IsValid() || !field_clang_type.IsValid())
- return NULL;
+ return nullptr;
- FieldDecl *field = NULL;
+ clang::FieldDecl *field = nullptr;
- clang::Expr *bit_width = NULL;
+ clang::Expr *bit_width = nullptr;
if (bitfield_bit_size != 0)
{
- APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size);
- bit_width = new (*m_ast)IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, SourceLocation());
+ llvm::APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size);
+ bit_width = new (*m_ast)clang::IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, clang::SourceLocation());
}
- RecordDecl *record_decl = GetAsRecordDecl ();
+ clang::RecordDecl *record_decl = GetAsRecordDecl ();
if (record_decl)
{
- field = FieldDecl::Create (*m_ast,
- record_decl,
- SourceLocation(),
- SourceLocation(),
- name ? &m_ast->Idents.get(name) : NULL, // Identifier
- field_clang_type.GetQualType(), // Field type
- NULL, // TInfo *
- bit_width, // BitWidth
- false, // Mutable
- ICIS_NoInit); // HasInit
+ field = clang::FieldDecl::Create (*m_ast,
+ record_decl,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ name ? &m_ast->Idents.get(name) : nullptr, // Identifier
+ field_clang_type.GetQualType(), // Field type
+ nullptr, // TInfo *
+ bit_width, // BitWidth
+ false, // Mutable
+ clang::ICIS_NoInit); // HasInit
if (!name)
{
// Determine whether this field corresponds to an anonymous
// struct or union.
- if (const TagType *TagT = field->getType()->getAs<TagType>()) {
- if (RecordDecl *Rec = dyn_cast<RecordDecl>(TagT->getDecl()))
+ if (const clang::TagType *TagT = field->getType()->getAs<clang::TagType>()) {
+ if (clang::RecordDecl *Rec = llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
if (!Rec->getDeclName()) {
Rec->setAnonymousStructOrUnion(true);
field->setImplicit();
@@ -4439,7 +4615,7 @@ ClangASTType::AddFieldToRecordType (const char *name,
}
else
{
- ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
+ clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
if (class_interface_decl)
{
@@ -4447,13 +4623,13 @@ ClangASTType::AddFieldToRecordType (const char *name,
field_clang_type.GetCompleteType();
- field = ObjCIvarDecl::Create (*m_ast,
+ field = clang::ObjCIvarDecl::Create (*m_ast,
class_interface_decl,
- SourceLocation(),
- SourceLocation(),
- name ? &m_ast->Idents.get(name) : NULL, // Identifier
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ name ? &m_ast->Idents.get(name) : nullptr, // Identifier
field_clang_type.GetQualType(), // Field type
- NULL, // TypeSourceInfo *
+ nullptr, // TypeSourceInfo *
ConvertAccessTypeToObjCIvarAccessControl (access),
bit_width,
is_synthesized);
@@ -4474,49 +4650,49 @@ ClangASTType::AddFieldToRecordType (const char *name,
void
ClangASTType::BuildIndirectFields ()
{
- RecordDecl *record_decl = GetAsRecordDecl();
+ clang::RecordDecl *record_decl = GetAsRecordDecl();
if (!record_decl)
return;
- typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector;
+ typedef llvm::SmallVector <clang::IndirectFieldDecl *, 1> IndirectFieldVector;
IndirectFieldVector indirect_fields;
- RecordDecl::field_iterator field_pos;
- RecordDecl::field_iterator field_end_pos = record_decl->field_end();
- RecordDecl::field_iterator last_field_pos = field_end_pos;
+ clang::RecordDecl::field_iterator field_pos;
+ clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end();
+ clang::RecordDecl::field_iterator last_field_pos = field_end_pos;
for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++)
{
if (field_pos->isAnonymousStructOrUnion())
{
- QualType field_qual_type = field_pos->getType();
+ clang::QualType field_qual_type = field_pos->getType();
- const RecordType *field_record_type = field_qual_type->getAs<RecordType>();
+ const clang::RecordType *field_record_type = field_qual_type->getAs<clang::RecordType>();
if (!field_record_type)
continue;
- RecordDecl *field_record_decl = field_record_type->getDecl();
+ clang::RecordDecl *field_record_decl = field_record_type->getDecl();
if (!field_record_decl)
continue;
- for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
+ for (clang::RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
di != de;
++di)
{
- if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di))
+ if (clang::FieldDecl *nested_field_decl = llvm::dyn_cast<clang::FieldDecl>(*di))
{
- NamedDecl **chain = new (*m_ast) NamedDecl*[2];
+ clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[2];
chain[0] = *field_pos;
chain[1] = nested_field_decl;
- IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast,
- record_decl,
- SourceLocation(),
- nested_field_decl->getIdentifier(),
- nested_field_decl->getType(),
- chain,
- 2);
+ clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast,
+ record_decl,
+ clang::SourceLocation(),
+ nested_field_decl->getIdentifier(),
+ nested_field_decl->getType(),
+ chain,
+ 2);
indirect_field->setImplicit();
@@ -4525,14 +4701,14 @@ ClangASTType::BuildIndirectFields ()
indirect_fields.push_back(indirect_field);
}
- else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di))
+ else if (clang::IndirectFieldDecl *nested_indirect_field_decl = llvm::dyn_cast<clang::IndirectFieldDecl>(*di))
{
int nested_chain_size = nested_indirect_field_decl->getChainingSize();
- NamedDecl **chain = new (*m_ast) NamedDecl*[nested_chain_size + 1];
+ clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[nested_chain_size + 1];
chain[0] = *field_pos;
int chain_index = 1;
- for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
+ for (clang::IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
nce = nested_indirect_field_decl->chain_end();
nci < nce;
++nci)
@@ -4541,13 +4717,13 @@ ClangASTType::BuildIndirectFields ()
chain_index++;
}
- IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast,
- record_decl,
- SourceLocation(),
- nested_indirect_field_decl->getIdentifier(),
- nested_indirect_field_decl->getType(),
- chain,
- nested_chain_size + 1);
+ clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast,
+ record_decl,
+ clang::SourceLocation(),
+ nested_indirect_field_decl->getIdentifier(),
+ nested_indirect_field_decl->getType(),
+ chain,
+ nested_chain_size + 1);
indirect_field->setImplicit();
@@ -4581,22 +4757,22 @@ ClangASTType::AddVariableToRecordType (const char *name,
const ClangASTType &var_type,
AccessType access)
{
- clang::VarDecl *var_decl = NULL;
+ clang::VarDecl *var_decl = nullptr;
if (!IsValid() || !var_type.IsValid())
- return NULL;
+ return nullptr;
- RecordDecl *record_decl = GetAsRecordDecl ();
+ clang::RecordDecl *record_decl = GetAsRecordDecl ();
if (record_decl)
{
- var_decl = VarDecl::Create (*m_ast, // ASTContext &
- record_decl, // DeclContext *
- SourceLocation(), // SourceLocation StartLoc
- SourceLocation(), // SourceLocation IdLoc
- name ? &m_ast->Idents.get(name) : NULL, // IdentifierInfo *
- var_type.GetQualType(), // Variable QualType
- NULL, // TypeSourceInfo *
- SC_Static); // StorageClass
+ var_decl = clang::VarDecl::Create (*m_ast, // ASTContext &
+ record_decl, // DeclContext *
+ clang::SourceLocation(), // clang::SourceLocation StartLoc
+ clang::SourceLocation(), // clang::SourceLocation IdLoc
+ name ? &m_ast->Idents.get(name) : nullptr, // clang::IdentifierInfo *
+ var_type.GetQualType(), // Variable clang::QualType
+ nullptr, // TypeSourceInfo *
+ clang::SC_Static); // StorageClass
if (var_decl)
{
var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
@@ -4611,7 +4787,7 @@ ClangASTType::AddVariableToRecordType (const char *name,
}
-CXXMethodDecl *
+clang::CXXMethodDecl *
ClangASTType::AddMethodToCXXRecordType (const char *name,
const ClangASTType &method_clang_type,
lldb::AccessType access,
@@ -4622,74 +4798,74 @@ ClangASTType::AddMethodToCXXRecordType (const char *name,
bool is_attr_used,
bool is_artificial)
{
- if (!IsValid() || !method_clang_type.IsValid() || name == NULL || name[0] == '\0')
- return NULL;
+ if (!IsValid() || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0')
+ return nullptr;
- QualType record_qual_type(GetCanonicalQualType());
+ clang::QualType record_qual_type(GetCanonicalQualType());
- CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
- if (cxx_record_decl == NULL)
- return NULL;
+ if (cxx_record_decl == nullptr)
+ return nullptr;
- QualType method_qual_type (method_clang_type.GetQualType());
+ clang::QualType method_qual_type (method_clang_type.GetQualType());
- CXXMethodDecl *cxx_method_decl = NULL;
+ clang::CXXMethodDecl *cxx_method_decl = nullptr;
- DeclarationName decl_name (&m_ast->Idents.get(name));
+ clang::DeclarationName decl_name (&m_ast->Idents.get(name));
- const clang::FunctionType *function_type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
+ const clang::FunctionType *function_type = llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
- if (function_type == NULL)
- return NULL;
+ if (function_type == nullptr)
+ return nullptr;
- const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_type));
+ const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(function_type));
if (!method_function_prototype)
- return NULL;
+ return nullptr;
unsigned int num_params = method_function_prototype->getNumParams();
- CXXDestructorDecl *cxx_dtor_decl(NULL);
- CXXConstructorDecl *cxx_ctor_decl(NULL);
+ clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
+ clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
if (is_artificial)
- return NULL; // skip everything artificial
+ return nullptr; // skip everything artificial
if (name[0] == '~')
{
- cxx_dtor_decl = CXXDestructorDecl::Create (*m_ast,
- cxx_record_decl,
- SourceLocation(),
- DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()),
- method_qual_type,
- NULL,
- is_inline,
- is_artificial);
+ cxx_dtor_decl = clang::CXXDestructorDecl::Create (*m_ast,
+ cxx_record_decl,
+ clang::SourceLocation(),
+ clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()),
+ method_qual_type,
+ nullptr,
+ is_inline,
+ is_artificial);
cxx_method_decl = cxx_dtor_decl;
}
else if (decl_name == cxx_record_decl->getDeclName())
{
- cxx_ctor_decl = CXXConstructorDecl::Create (*m_ast,
- cxx_record_decl,
- SourceLocation(),
- DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()),
- method_qual_type,
- NULL, // TypeSourceInfo *
- is_explicit,
- is_inline,
- is_artificial,
- false /*is_constexpr*/);
+ cxx_ctor_decl = clang::CXXConstructorDecl::Create (*m_ast,
+ cxx_record_decl,
+ clang::SourceLocation(),
+ clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()),
+ method_qual_type,
+ nullptr, // TypeSourceInfo *
+ is_explicit,
+ is_inline,
+ is_artificial,
+ false /*is_constexpr*/);
cxx_method_decl = cxx_ctor_decl;
}
else
{
- clang::StorageClass SC = is_static ? SC_Static : SC_None;
- OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
+ clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
+ clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
if (IsOperator (name, op_kind))
{
- if (op_kind != NUM_OVERLOADED_OPERATORS)
+ if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
{
// Check the number of operator parameters. Sometimes we have
// seen bad DWARF that doesn't correctly describe operators and
@@ -4697,50 +4873,50 @@ ClangASTType::AddMethodToCXXRecordType (const char *name,
// will assert and crash, so we need to make sure things are
// acceptable.
if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
- return NULL;
- cxx_method_decl = CXXMethodDecl::Create (*m_ast,
- cxx_record_decl,
- SourceLocation(),
- DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
- method_qual_type,
- NULL, // TypeSourceInfo *
- SC,
- is_inline,
- false /*is_constexpr*/,
- SourceLocation());
+ return nullptr;
+ cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast,
+ cxx_record_decl,
+ clang::SourceLocation(),
+ clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), clang::SourceLocation()),
+ method_qual_type,
+ nullptr, // TypeSourceInfo *
+ SC,
+ is_inline,
+ false /*is_constexpr*/,
+ clang::SourceLocation());
}
else if (num_params == 0)
{
// Conversion operators don't take params...
- cxx_method_decl = CXXConversionDecl::Create (*m_ast,
- cxx_record_decl,
- SourceLocation(),
- DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getReturnType())), SourceLocation()),
- method_qual_type,
- NULL, // TypeSourceInfo *
- is_inline,
- is_explicit,
- false /*is_constexpr*/,
- SourceLocation());
+ cxx_method_decl = clang::CXXConversionDecl::Create (*m_ast,
+ cxx_record_decl,
+ clang::SourceLocation(),
+ clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getReturnType())), clang::SourceLocation()),
+ method_qual_type,
+ nullptr, // TypeSourceInfo *
+ is_inline,
+ is_explicit,
+ false /*is_constexpr*/,
+ clang::SourceLocation());
}
}
- if (cxx_method_decl == NULL)
+ if (cxx_method_decl == nullptr)
{
- cxx_method_decl = CXXMethodDecl::Create (*m_ast,
- cxx_record_decl,
- SourceLocation(),
- DeclarationNameInfo (decl_name, SourceLocation()),
- method_qual_type,
- NULL, // TypeSourceInfo *
- SC,
- is_inline,
- false /*is_constexpr*/,
- SourceLocation());
+ cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast,
+ cxx_record_decl,
+ clang::SourceLocation(),
+ clang::DeclarationNameInfo (decl_name, clang::SourceLocation()),
+ method_qual_type,
+ nullptr, // TypeSourceInfo *
+ SC,
+ is_inline,
+ false /*is_constexpr*/,
+ clang::SourceLocation());
}
}
- AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access);
+ clang::AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access);
cxx_method_decl->setAccess (access_specifier);
cxx_method_decl->setVirtualAsWritten (is_virtual);
@@ -4750,24 +4926,24 @@ ClangASTType::AddMethodToCXXRecordType (const char *name,
// Populate the method decl with parameter decls
- llvm::SmallVector<ParmVarDecl *, 12> params;
+ llvm::SmallVector<clang::ParmVarDecl *, 12> params;
for (unsigned param_index = 0;
param_index < num_params;
++param_index)
{
- params.push_back (ParmVarDecl::Create (*m_ast,
- cxx_method_decl,
- SourceLocation(),
- SourceLocation(),
- NULL, // anonymous
- method_function_prototype->getParamType(param_index),
- NULL,
- SC_None,
- NULL));
+ params.push_back (clang::ParmVarDecl::Create (*m_ast,
+ cxx_method_decl,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ nullptr, // anonymous
+ method_function_prototype->getParamType(param_index),
+ nullptr,
+ clang::SC_None,
+ nullptr));
}
- cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params));
+ cxx_method_decl->setParams (llvm::ArrayRef<clang::ParmVarDecl*>(params));
cxx_record_decl->addDecl (cxx_method_decl);
@@ -4823,36 +4999,36 @@ ClangASTType::AddMethodToCXXRecordType (const char *name,
#pragma mark C++ Base Classes
-CXXBaseSpecifier *
+clang::CXXBaseSpecifier *
ClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class)
{
if (IsValid())
- return new CXXBaseSpecifier (SourceRange(),
- is_virtual,
- base_of_class,
- ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
- m_ast->getTrivialTypeSourceInfo (GetQualType()),
- SourceLocation());
- return NULL;
+ return new clang::CXXBaseSpecifier (clang::SourceRange(),
+ is_virtual,
+ base_of_class,
+ ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
+ m_ast->getTrivialTypeSourceInfo (GetQualType()),
+ clang::SourceLocation());
+ return nullptr;
}
void
-ClangASTType::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
+ClangASTType::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes)
{
for (unsigned i=0; i<num_base_classes; ++i)
{
delete base_classes[i];
- base_classes[i] = NULL;
+ base_classes[i] = nullptr;
}
}
bool
-ClangASTType::SetBaseClassesForClassType (CXXBaseSpecifier const * const *base_classes,
+ClangASTType::SetBaseClassesForClassType (clang::CXXBaseSpecifier const * const *base_classes,
unsigned num_base_classes)
{
if (IsValid())
{
- CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl();
if (cxx_record_decl)
{
cxx_record_decl->setBases(base_classes, num_base_classes);
@@ -4867,8 +5043,8 @@ ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type)
{
if (IsValid() && superclass_clang_type.IsValid())
{
- ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
- ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl ();
+ clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
+ clang::ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl ();
if (class_interface_decl && super_interface_decl)
{
class_interface_decl->setSuperClass(super_interface_decl);
@@ -4881,16 +5057,16 @@ ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type)
bool
ClangASTType::AddObjCClassProperty (const char *property_name,
const ClangASTType &property_clang_type,
- ObjCIvarDecl *ivar_decl,
+ clang::ObjCIvarDecl *ivar_decl,
const char *property_setter_name,
const char *property_getter_name,
uint32_t property_attributes,
ClangASTMetadata *metadata)
{
- if (!IsValid() || !property_clang_type.IsValid() || property_name == NULL || property_name[0] == '\0')
+ if (!IsValid() || !property_clang_type.IsValid() || property_name == nullptr || property_name[0] == '\0')
return false;
- ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
+ clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
if (class_interface_decl)
{
@@ -4909,13 +5085,13 @@ ClangASTType::AddObjCClassProperty (const char *property_name,
else
prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType());
- ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create (*m_ast,
- class_interface_decl,
- SourceLocation(), // Source Location
- &m_ast->Idents.get(property_name),
- SourceLocation(), //Source Location for AT
- SourceLocation(), //Source location for (
- prop_type_source);
+ clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create (*m_ast,
+ class_interface_decl,
+ clang::SourceLocation(), // Source Location
+ &m_ast->Idents.get(property_name),
+ clang::SourceLocation(), //Source Location for AT
+ clang::SourceLocation(), //Source location for (
+ prop_type_source);
if (property_decl)
{
@@ -4924,9 +5100,9 @@ ClangASTType::AddObjCClassProperty (const char *property_name,
class_interface_decl->addDecl (property_decl);
- Selector setter_sel, getter_sel;
+ clang::Selector setter_sel, getter_sel;
- if (property_setter_name != NULL)
+ if (property_setter_name != nullptr)
{
std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1);
clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(property_setter_no_colon.c_str());
@@ -4943,7 +5119,7 @@ ClangASTType::AddObjCClassProperty (const char *property_name,
property_decl->setSetterName(setter_sel);
property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter);
- if (property_getter_name != NULL)
+ if (property_getter_name != nullptr)
{
clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_getter_name);
getter_sel = m_ast->Selectors.getSelector(0, &getter_ident);
@@ -4979,75 +5155,75 @@ ClangASTType::AddObjCClassProperty (const char *property_name,
const bool isSynthesized = false;
const bool isImplicitlyDeclared = true;
const bool isDefined = false;
- const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
+ const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
const bool HasRelatedResultType = false;
- ObjCMethodDecl *getter = ObjCMethodDecl::Create (*m_ast,
- SourceLocation(),
- SourceLocation(),
- getter_sel,
- property_clang_type_to_access.GetQualType(),
- NULL,
- class_interface_decl,
- isInstance,
- isVariadic,
- isSynthesized,
- isImplicitlyDeclared,
- isDefined,
- impControl,
- HasRelatedResultType);
+ clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create (*m_ast,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ getter_sel,
+ property_clang_type_to_access.GetQualType(),
+ nullptr,
+ class_interface_decl,
+ isInstance,
+ isVariadic,
+ isSynthesized,
+ isImplicitlyDeclared,
+ isDefined,
+ impControl,
+ HasRelatedResultType);
if (getter && metadata)
ClangASTContext::SetMetadata(m_ast, getter, *metadata);
- getter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>());
+ getter->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(), llvm::ArrayRef<clang::SourceLocation>());
class_interface_decl->addDecl(getter);
}
if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel))
{
- QualType result_type = m_ast->VoidTy;
+ clang::QualType result_type = m_ast->VoidTy;
const bool isInstance = true;
const bool isVariadic = false;
const bool isSynthesized = false;
const bool isImplicitlyDeclared = true;
const bool isDefined = false;
- const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
+ const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
const bool HasRelatedResultType = false;
- ObjCMethodDecl *setter = ObjCMethodDecl::Create (*m_ast,
- SourceLocation(),
- SourceLocation(),
- setter_sel,
- result_type,
- NULL,
- class_interface_decl,
- isInstance,
- isVariadic,
- isSynthesized,
- isImplicitlyDeclared,
- isDefined,
- impControl,
- HasRelatedResultType);
+ clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create (*m_ast,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ setter_sel,
+ result_type,
+ nullptr,
+ class_interface_decl,
+ isInstance,
+ isVariadic,
+ isSynthesized,
+ isImplicitlyDeclared,
+ isDefined,
+ impControl,
+ HasRelatedResultType);
if (setter && metadata)
ClangASTContext::SetMetadata(m_ast, setter, *metadata);
- llvm::SmallVector<ParmVarDecl *, 1> params;
+ llvm::SmallVector<clang::ParmVarDecl *, 1> params;
- params.push_back (ParmVarDecl::Create (*m_ast,
- setter,
- SourceLocation(),
- SourceLocation(),
- NULL, // anonymous
- property_clang_type_to_access.GetQualType(),
- NULL,
- SC_Auto,
- NULL));
+ params.push_back (clang::ParmVarDecl::Create (*m_ast,
+ setter,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ nullptr, // anonymous
+ property_clang_type_to_access.GetQualType(),
+ nullptr,
+ clang::SC_Auto,
+ nullptr));
- setter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
+ setter->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
class_interface_decl->addDecl(setter);
}
@@ -5062,33 +5238,33 @@ ClangASTType::AddObjCClassProperty (const char *property_name,
bool
ClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const
{
- ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
+ clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
if (class_interface_decl)
return ObjCDeclHasIVars (class_interface_decl, check_superclass);
return false;
}
-ObjCMethodDecl *
+clang::ObjCMethodDecl *
ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
const ClangASTType &method_clang_type,
lldb::AccessType access,
bool is_artificial)
{
if (!IsValid() || !method_clang_type.IsValid())
- return NULL;
+ return nullptr;
- ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl();
+ clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl();
- if (class_interface_decl == NULL)
- return NULL;
+ if (class_interface_decl == nullptr)
+ return nullptr;
const char *selector_start = ::strchr (name, ' ');
- if (selector_start == NULL)
- return NULL;
+ if (selector_start == nullptr)
+ return nullptr;
selector_start++;
- llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
+ llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents;
size_t len = 0;
const char *start;
@@ -5103,79 +5279,79 @@ ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol n
bool has_arg = (start[len] == ':');
if (has_arg)
++num_selectors_with_args;
- selector_idents.push_back (&m_ast->Idents.get (StringRef (start, len)));
+ selector_idents.push_back (&m_ast->Idents.get (llvm::StringRef (start, len)));
if (has_arg)
len += 1;
}
if (selector_idents.size() == 0)
- return 0;
+ return nullptr;
clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
selector_idents.data());
- QualType method_qual_type (method_clang_type.GetQualType());
+ clang::QualType method_qual_type (method_clang_type.GetQualType());
// Populate the method decl with parameter decls
const clang::Type *method_type(method_qual_type.getTypePtr());
- if (method_type == NULL)
- return NULL;
+ if (method_type == nullptr)
+ return nullptr;
- const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
+ const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(method_type));
if (!method_function_prototype)
- return NULL;
+ return nullptr;
bool is_variadic = false;
bool is_synthesized = false;
bool is_defined = false;
- ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
+ clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None;
const unsigned num_args = method_function_prototype->getNumParams();
if (num_args != num_selectors_with_args)
- return NULL; // some debug information is corrupt. We are not going to deal with it.
+ return nullptr; // some debug information is corrupt. We are not going to deal with it.
- ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*m_ast,
- SourceLocation(), // beginLoc,
- SourceLocation(), // endLoc,
- method_selector,
- method_function_prototype->getReturnType(),
- NULL, // TypeSourceInfo *ResultTInfo,
- GetDeclContextForType (),
- name[0] == '-',
- is_variadic,
- is_synthesized,
- true, // is_implicitly_declared; we force this to true because we don't have source locations
- is_defined,
- imp_control,
- false /*has_related_result_type*/);
+ clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create (*m_ast,
+ clang::SourceLocation(), // beginLoc,
+ clang::SourceLocation(), // endLoc,
+ method_selector,
+ method_function_prototype->getReturnType(),
+ nullptr, // TypeSourceInfo *ResultTInfo,
+ GetDeclContextForType (),
+ name[0] == '-',
+ is_variadic,
+ is_synthesized,
+ true, // is_implicitly_declared; we force this to true because we don't have source locations
+ is_defined,
+ imp_control,
+ false /*has_related_result_type*/);
- if (objc_method_decl == NULL)
- return NULL;
+ if (objc_method_decl == nullptr)
+ return nullptr;
if (num_args > 0)
{
- llvm::SmallVector<ParmVarDecl *, 12> params;
+ llvm::SmallVector<clang::ParmVarDecl *, 12> params;
for (unsigned param_index = 0; param_index < num_args; ++param_index)
{
- params.push_back (ParmVarDecl::Create (*m_ast,
- objc_method_decl,
- SourceLocation(),
- SourceLocation(),
- NULL, // anonymous
- method_function_prototype->getParamType(param_index),
- NULL,
- SC_Auto,
- NULL));
+ params.push_back (clang::ParmVarDecl::Create (*m_ast,
+ objc_method_decl,
+ clang::SourceLocation(),
+ clang::SourceLocation(),
+ nullptr, // anonymous
+ method_function_prototype->getParamType(param_index),
+ nullptr,
+ clang::SC_Auto,
+ nullptr));
}
- objc_method_decl->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
+ objc_method_decl->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
}
class_interface_decl->addDecl (objc_method_decl);
@@ -5192,9 +5368,9 @@ clang::DeclContext *
ClangASTType::GetDeclContextForType () const
{
if (!IsValid())
- return NULL;
+ return nullptr;
- QualType qual_type(GetCanonicalQualType());
+ clang::QualType qual_type(GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
@@ -5216,13 +5392,13 @@ ClangASTType::GetDeclContextForType () const
case clang::Type::MemberPointer: break;
case clang::Type::Complex: break;
case clang::Type::ObjCObject: break;
- case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
- case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType();
- case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl();
- case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl();
- case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType();
- case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType();
- case clang::Type::Paren: return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetDeclContextForType();
+ case clang::Type::ObjCInterface: return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())->getInterface();
+ case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType();
+ case clang::Type::Record: return llvm::cast<clang::RecordType>(qual_type)->getDecl();
+ case clang::Type::Enum: return llvm::cast<clang::EnumType>(qual_type)->getDecl();
+ case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType();
+ case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType();
+ case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetDeclContextForType();
case clang::Type::TypeOfExpr: break;
case clang::Type::TypeOf: break;
case clang::Type::Decltype: break;
@@ -5239,12 +5415,13 @@ ClangASTType::GetDeclContextForType () const
case clang::Type::InjectedClassName: break;
case clang::Type::DependentName: break;
case clang::Type::Atomic: break;
+ case clang::Type::Adjusted: break;
// pointer type decayed from an array or function type.
case clang::Type::Decayed: break;
}
// No DeclContext in this type...
- return NULL;
+ return nullptr;
}
bool
@@ -5254,18 +5431,18 @@ ClangASTType::SetDefaultAccessForRecordFields (int default_accessibility,
{
if (IsValid())
{
- RecordDecl *record_decl = GetAsRecordDecl();
+ clang::RecordDecl *record_decl = GetAsRecordDecl();
if (record_decl)
{
uint32_t field_idx;
- RecordDecl::field_iterator field, field_end;
+ clang::RecordDecl::field_iterator field, field_end;
for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
field != field_end;
++field, ++field_idx)
{
// If no accessibility was assigned, assign the correct one
if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
- field->setAccess ((AccessSpecifier)default_accessibility);
+ field->setAccess ((clang::AccessSpecifier)default_accessibility);
}
return true;
}
@@ -5280,14 +5457,14 @@ ClangASTType::SetHasExternalStorage (bool has_extern)
if (!IsValid())
return false;
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Record:
{
- CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
cxx_record_decl->setHasExternalLexicalStorage (has_extern);
@@ -5299,7 +5476,7 @@ ClangASTType::SetHasExternalStorage (bool has_extern)
case clang::Type::Enum:
{
- EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl();
+ clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
if (enum_decl)
{
enum_decl->setHasExternalLexicalStorage (has_extern);
@@ -5312,11 +5489,11 @@ ClangASTType::SetHasExternalStorage (bool has_extern)
case clang::Type::ObjCObject:
case clang::Type::ObjCInterface:
{
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
@@ -5329,13 +5506,13 @@ ClangASTType::SetHasExternalStorage (bool has_extern)
break;
case clang::Type::Typedef:
- return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern);
+ return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern);
case clang::Type::Elaborated:
- return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern);
+ return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern);
case clang::Type::Paren:
- return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern);
+ return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern);
default:
break;
@@ -5348,17 +5525,17 @@ ClangASTType::SetTagTypeKind (int kind) const
{
if (IsValid())
{
- QualType tag_qual_type(GetQualType());
+ clang::QualType tag_qual_type(GetQualType());
const clang::Type *clang_type = tag_qual_type.getTypePtr();
if (clang_type)
{
- const TagType *tag_type = dyn_cast<TagType>(clang_type);
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
if (tag_type)
{
- TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
+ clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
if (tag_decl)
{
- tag_decl->setTagKind ((TagDecl::TagKind)kind);
+ tag_decl->setTagKind ((clang::TagDecl::TagKind)kind);
return true;
}
}
@@ -5375,14 +5552,14 @@ ClangASTType::StartTagDeclarationDefinition ()
{
if (IsValid())
{
- QualType qual_type (GetQualType());
+ clang::QualType qual_type (GetQualType());
const clang::Type *t = qual_type.getTypePtr();
if (t)
{
- const TagType *tag_type = dyn_cast<TagType>(t);
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(t);
if (tag_type)
{
- TagDecl *tag_decl = tag_type->getDecl();
+ clang::TagDecl *tag_decl = tag_type->getDecl();
if (tag_decl)
{
tag_decl->startDefinition();
@@ -5390,10 +5567,10 @@ ClangASTType::StartTagDeclarationDefinition ()
}
}
- const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t);
+ const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(t);
if (object_type)
{
- ObjCInterfaceDecl *interface_decl = object_type->getInterface();
+ clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
if (interface_decl)
{
interface_decl->startDefinition();
@@ -5410,9 +5587,9 @@ ClangASTType::CompleteTagDeclarationDefinition ()
{
if (IsValid())
{
- QualType qual_type (GetQualType());
+ clang::QualType qual_type (GetQualType());
- CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+ clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
if (cxx_record_decl)
{
@@ -5421,11 +5598,11 @@ ClangASTType::CompleteTagDeclarationDefinition ()
return true;
}
- const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
+ const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(qual_type.getTypePtr());
if (enum_type)
{
- EnumDecl *enum_decl = enum_type->getDecl();
+ clang::EnumDecl *enum_decl = enum_type->getDecl();
if (enum_decl)
{
@@ -5434,7 +5611,7 @@ ClangASTType::CompleteTagDeclarationDefinition ()
unsigned NumPositiveBits = 1;
unsigned NumNegativeBits = 0;
- QualType promotion_qual_type;
+ clang::QualType promotion_qual_type;
// If the enum integer type is less than an integer in bit width,
// then we must promote it to an integer size.
if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy))
@@ -5470,27 +5647,27 @@ ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerat
{
if (IsValid() && enumerator_clang_type.IsValid() && name && name[0])
{
- QualType enum_qual_type (GetCanonicalQualType());
+ clang::QualType enum_qual_type (GetCanonicalQualType());
bool is_signed = false;
enumerator_clang_type.IsIntegerType (is_signed);
const clang::Type *clang_type = enum_qual_type.getTypePtr();
if (clang_type)
{
- const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
+ const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(clang_type);
if (enum_type)
{
llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed);
enum_llvm_apsint = enum_value;
- EnumConstantDecl *enumerator_decl =
- EnumConstantDecl::Create (*m_ast,
- enum_type->getDecl(),
- SourceLocation(),
- name ? &m_ast->Idents.get(name) : NULL, // Identifier
- enumerator_clang_type.GetQualType(),
- NULL,
- enum_llvm_apsint);
+ clang::EnumConstantDecl *enumerator_decl =
+ clang::EnumConstantDecl::Create (*m_ast,
+ enum_type->getDecl(),
+ clang::SourceLocation(),
+ name ? &m_ast->Idents.get(name) : nullptr, // Identifier
+ enumerator_clang_type.GetQualType(),
+ nullptr,
+ enum_llvm_apsint);
if (enumerator_decl)
{
@@ -5512,14 +5689,14 @@ ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerat
ClangASTType
ClangASTType::GetEnumerationIntegerType () const
{
- QualType enum_qual_type (GetCanonicalQualType());
+ clang::QualType enum_qual_type (GetCanonicalQualType());
const clang::Type *clang_type = enum_qual_type.getTypePtr();
if (clang_type)
{
- const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
+ const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(clang_type);
if (enum_type)
{
- EnumDecl *enum_decl = enum_type->getDecl();
+ clang::EnumDecl *enum_decl = enum_type->getDecl();
if (enum_decl)
return ClangASTType (m_ast, enum_decl->getIntegerType());
}
@@ -5544,7 +5721,7 @@ ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst
{
if (IsValid())
{
- QualType qual_type (GetCanonicalQualType());
+ clang::QualType qual_type (GetCanonicalQualType());
uint32_t count = 0;
bool is_complex = false;
if (IsFloatingPointType (count, is_complex))
@@ -5553,8 +5730,8 @@ ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst
if (count != 1)
return false;
- StringRef s_sref(s);
- APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref);
+ llvm::StringRef s_sref(s);
+ llvm::APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref);
const uint64_t bit_size = m_ast->getTypeSize (qual_type);
const uint64_t byte_size = bit_size / 8;
@@ -5602,30 +5779,30 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
if (!IsValid())
return;
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
switch (qual_type->getTypeClass())
{
case clang::Type::Record:
if (GetCompleteType ())
{
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
+ 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 ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
+ const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
uint32_t child_idx = 0;
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ 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
- CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
+ 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 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
+ 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)
@@ -5642,13 +5819,13 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
else
s->PutChar(',');
- QualType base_class_qual_type = base_class->getType();
+ 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 = m_ast->getTypeInfo(base_class_qual_type);
+ clang::TypeInfo base_class_type_info = m_ast->getTypeInfo(base_class_qual_type);
// Dump the value of the member
ClangASTType base_clang_type(m_ast, base_class_qual_type);
@@ -5657,7 +5834,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
base_clang_type.GetFormat(), // 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
+ base_class_type_info.Width / 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
@@ -5669,7 +5846,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
}
}
uint32_t field_idx = 0;
- RecordDecl::field_iterator field, field_end;
+ 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
@@ -5683,11 +5860,11 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
// Indent
s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
- QualType field_type = field->getType();
+ 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 = m_ast->getTypeInfo(field_type);
+ clang::TypeInfo field_type_info = m_ast->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);
@@ -5716,7 +5893,7 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
field_clang_type.GetFormat(), // 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_type_info.Width / 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
@@ -5734,10 +5911,10 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
case clang::Type::Enum:
if (GetCompleteType ())
{
- const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr());
- const EnumDecl *enum_decl = enum_type->getDecl();
+ const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
+ const clang::EnumDecl *enum_decl = enum_type->getDecl();
assert(enum_decl);
- EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
+ clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
lldb::offset_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)
@@ -5756,9 +5933,9 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
case clang::Type::ConstantArray:
{
- const ConstantArrayType *array = cast<ConstantArrayType>(qual_type.getTypePtr());
+ const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr());
bool is_array_of_characters = false;
- QualType element_qual_type = array->getElementType();
+ clang::QualType element_qual_type = array->getElementType();
const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
if (canonical_type)
@@ -5766,11 +5943,11 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
const uint64_t element_count = array->getSize().getLimitedValue();
- std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(element_qual_type);
+ clang::TypeInfo field_type_info = m_ast->getTypeInfo(element_qual_type);
uint32_t element_idx = 0;
uint32_t element_offset = 0;
- uint64_t element_byte_size = field_type_info.first / 8;
+ uint64_t element_byte_size = field_type_info.Width / 8;
uint32_t element_stride = element_byte_size;
if (is_array_of_characters)
@@ -5825,12 +6002,12 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
case clang::Type::Typedef:
{
- QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType();
+ clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
lldb::Format typedef_format = typedef_clang_type.GetFormat();
- std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
- uint64_t typedef_byte_size = typedef_type_info.first / 8;
+ clang::TypeInfo typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
+ uint64_t typedef_byte_size = typedef_type_info.Width / 8;
return typedef_clang_type.DumpValue (exe_ctx,
s, // Stream to dump to
@@ -5849,11 +6026,11 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
case clang::Type::Elaborated:
{
- QualType elaborated_qual_type = cast<ElaboratedType>(qual_type)->getNamedType();
+ clang::QualType elaborated_qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type);
lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
- std::pair<uint64_t, unsigned> elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type);
- uint64_t elaborated_byte_size = elaborated_type_info.first / 8;
+ clang::TypeInfo elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type);
+ uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
return elaborated_clang_type.DumpValue (exe_ctx,
s, // Stream to dump to
@@ -5872,12 +6049,12 @@ ClangASTType::DumpValue (ExecutionContext *exe_ctx,
case clang::Type::Paren:
{
- QualType desugar_qual_type = cast<ParenType>(qual_type)->desugar();
+ clang::QualType desugar_qual_type = llvm::cast<clang::ParenType>(qual_type)->desugar();
ClangASTType desugar_clang_type (m_ast, desugar_qual_type);
lldb::Format desugar_format = desugar_clang_type.GetFormat();
- std::pair<uint64_t, unsigned> desugar_type_info = m_ast->getTypeInfo(desugar_qual_type);
- uint64_t desugar_byte_size = desugar_type_info.first / 8;
+ clang::TypeInfo desugar_type_info = m_ast->getTypeInfo(desugar_qual_type);
+ uint64_t desugar_byte_size = desugar_type_info.Width / 8;
return desugar_clang_type.DumpValue (exe_ctx,
s, // Stream to dump to
@@ -5933,19 +6110,19 @@ ClangASTType::DumpTypeValue (Stream *s,
}
else
{
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
{
case clang::Type::Typedef:
{
- QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType();
+ clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
if (format == eFormatDefault)
format = typedef_clang_type.GetFormat();
- std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
- uint64_t typedef_byte_size = typedef_type_info.first / 8;
+ clang::TypeInfo typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
+ uint64_t typedef_byte_size = typedef_type_info.Width / 8;
return typedef_clang_type.DumpTypeValue (s,
format, // The format with which to display the element
@@ -5963,10 +6140,10 @@ ClangASTType::DumpTypeValue (Stream *s,
// its enumeration string value, else just display it as requested.
if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ())
{
- const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr());
- const EnumDecl *enum_decl = enum_type->getDecl();
+ const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
+ const clang::EnumDecl *enum_decl = enum_type->getDecl();
assert(enum_decl);
- EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
+ clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
const bool is_signed = qual_type->isSignedIntegerOrEnumerationType();
lldb::offset_t offset = byte_offset;
if (is_signed)
@@ -6093,7 +6270,7 @@ ClangASTType::DumpSummary (ExecutionContext *exe_ctx,
if (process)
{
lldb::offset_t offset = data_byte_offset;
- lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size);
+ lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
std::vector<uint8_t> buf;
if (length > 0)
buf.resize (length);
@@ -6105,7 +6282,7 @@ ClangASTType::DumpSummary (ExecutionContext *exe_ctx,
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)
+ while ((bytes_read = process->ReadMemory (pointer_address, &buf.front(), buf.size(), error)) > 0)
{
const size_t len = strlen((const char *)&buf.front());
if (len == 0)
@@ -6116,7 +6293,7 @@ ClangASTType::DumpSummary (ExecutionContext *exe_ctx,
total_cstr_len += len;
if (len < buf.size())
break;
- pointer_addresss += total_cstr_len;
+ pointer_address += total_cstr_len;
}
if (total_cstr_len > 0)
s->PutChar ('"');
@@ -6142,10 +6319,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const
{
if (IsValid())
{
- QualType qual_type(GetQualType());
+ clang::QualType qual_type(GetQualType());
- SmallVector<char, 1024> buf;
- raw_svector_ostream llvm_ostrm (buf);
+ llvm::SmallVector<char, 1024> buf;
+ llvm::raw_svector_ostream llvm_ostrm (buf);
const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class)
@@ -6155,14 +6332,14 @@ ClangASTType::DumpTypeDescription (Stream *s) const
{
GetCompleteType ();
- const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+ const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
assert (objc_class_type);
if (objc_class_type)
{
- ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+ clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
if (class_interface_decl)
{
- PrintingPolicy policy = m_ast->getPrintingPolicy();
+ clang::PrintingPolicy policy = m_ast->getPrintingPolicy();
class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel());
}
}
@@ -6171,10 +6348,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const
case clang::Type::Typedef:
{
- const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
+ const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
if (typedef_type)
{
- const TypedefNameDecl *typedef_decl = typedef_type->getDecl();
+ const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString());
if (!clang_typedef_name.empty())
{
@@ -6186,20 +6363,20 @@ ClangASTType::DumpTypeDescription (Stream *s) const
break;
case clang::Type::Elaborated:
- ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s);
+ ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s);
return;
case clang::Type::Paren:
- ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).DumpTypeDescription(s);
+ ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).DumpTypeDescription(s);
return;
case clang::Type::Record:
{
GetCompleteType ();
- const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
- const RecordDecl *record_decl = record_type->getDecl();
- const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
+ 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, m_ast->getPrintingPolicy(), s->GetIndentLevel());
@@ -6210,10 +6387,10 @@ ClangASTType::DumpTypeDescription (Stream *s) const
default:
{
- const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
+ const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
if (tag_type)
{
- TagDecl *tag_decl = tag_type->getDecl();
+ clang::TagDecl *tag_decl = tag_type->getDecl();
if (tag_decl)
tag_decl->print(llvm_ostrm, 0);
}
@@ -6471,19 +6648,19 @@ ClangASTType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx,
}
uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size);
- if (dst != NULL)
+ if (dst != nullptr)
{
if (address_type == eAddressTypeHost)
{
if (addr == 0)
return false;
// The address is an address in this process, so just copy it
- memcpy (dst, (uint8_t*)NULL + addr, byte_size);
+ memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
return true;
}
else
{
- Process *process = NULL;
+ Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process)
@@ -6525,7 +6702,7 @@ ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
}
else
{
- Process *process = NULL;
+ Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process)
@@ -6539,11 +6716,11 @@ ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
}
-//CXXRecordDecl *
+//clang::CXXRecordDecl *
//ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type)
//{
// if (opaque_clang_qual_type)
-// return QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl();
+// return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl();
// return NULL;
//}
@@ -6561,3 +6738,4 @@ lldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_pri
}
+