From: Vassil Vassilev Date: Wed, 30 Mar 2016 22:18:29 +0000 (+0000) Subject: Canonicalize UnaryTransformType types when they don't have a known underlying type. X-Git-Tag: llvmorg-3.9.0-rc1~10459 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=bab6f96fff363fbfdc15fd1f62452ff243da843c;p=platform%2Fupstream%2Fllvm.git Canonicalize UnaryTransformType types when they don't have a known underlying type. Fixes https://llvm.org/bugs/show_bug.cgi?id=26014 Reviewed by Richard Smith. llvm-svn: 264937 --- diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 2851c4d..55511e0 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -129,6 +129,8 @@ class ASTContext : public RefCountedBase { llvm::FoldingSet PackExpansionTypes; mutable llvm::FoldingSet ObjCObjectTypes; mutable llvm::FoldingSet ObjCObjectPointerTypes; + mutable llvm::FoldingSet + DependentUnaryTransformTypes; mutable llvm::FoldingSet AutoTypes; mutable llvm::FoldingSet AtomicTypes; llvm::FoldingSet AttributedTypes; diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index aef891c..e8f54fd 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -3633,6 +3633,28 @@ public: } }; +/// \brief Internal representation of canonical, dependent +/// __underlying_type(type) types. +/// +/// This class is used internally by the ASTContext to manage +/// canonical, dependent types, only. Clients will only see instances +/// of this class via UnaryTransformType nodes. +class DependentUnaryTransformType : public UnaryTransformType, + public llvm::FoldingSetNode { +public: + DependentUnaryTransformType(const ASTContext &C, QualType BaseType, + UTTKind UKind); + void Profile(llvm::FoldingSetNodeID &ID) { + Profile(ID, getBaseType(), getUTTKind()); + } + + static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType, + UTTKind UKind) { + ID.AddPointer(BaseType.getAsOpaquePtr()); + ID.AddInteger((unsigned)UKind); + } +}; + class TagType : public Type { /// Stores the TagDecl associated with this type. The decl may point to any /// TagDecl that declares the entity. diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index 77e5087..aa9277c 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -4020,13 +4020,35 @@ QualType ASTContext::getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind Kind) const { - UnaryTransformType *Ty = - new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, - Kind, - UnderlyingType->isDependentType() ? - QualType() : getCanonicalType(UnderlyingType)); - Types.push_back(Ty); - return QualType(Ty, 0); + UnaryTransformType *ut = nullptr; + + if (BaseType->isDependentType()) { + // Look in the folding set for an existing type. + llvm::FoldingSetNodeID ID; + DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind); + + void *InsertPos = nullptr; + DependentUnaryTransformType *Canon + = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos); + + if (!Canon) { + // Build a new, canonical __underlying_type(type) type. + Canon = new (*this, TypeAlignment) + DependentUnaryTransformType(*this, getCanonicalType(BaseType), + Kind); + DependentUnaryTransformTypes.InsertNode(Canon, InsertPos); + } + ut = new (*this, TypeAlignment) UnaryTransformType (BaseType, + QualType(), Kind, + QualType(Canon, 0)); + } else { + QualType CanonType = getCanonicalType(UnderlyingType); + ut = new (*this, TypeAlignment) UnaryTransformType (BaseType, + UnderlyingType, Kind, + CanonType); + } + Types.push_back(ut); + return QualType(ut, 0); } /// getAutoType - Return the uniqued reference to the 'auto' type which has been diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 74aa323..d3c7259 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -2935,6 +2935,24 @@ void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, E->Profile(ID, Context, true); } +UnaryTransformType::UnaryTransformType(QualType BaseType, + QualType UnderlyingType, + UTTKind UKind, + QualType CanonicalType) + : Type(UnaryTransform, CanonicalType, BaseType->isDependentType(), + BaseType->isInstantiationDependentType(), + BaseType->isVariablyModifiedType(), + BaseType->containsUnexpandedParameterPack()) + , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) +{} + +DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C, + QualType BaseType, + UTTKind UKind) + : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) +{} + + TagType::TagType(TypeClass TC, const TagDecl *D, QualType can) : Type(TC, can, D->isDependentType(), /*InstantiationDependent=*/D->isDependentType(), @@ -2951,17 +2969,6 @@ static TagDecl *getInterestingTagDecl(TagDecl *decl) { return decl; } -UnaryTransformType::UnaryTransformType(QualType BaseType, - QualType UnderlyingType, - UTTKind UKind, - QualType CanonicalType) - : Type(UnaryTransform, CanonicalType, UnderlyingType->isDependentType(), - UnderlyingType->isInstantiationDependentType(), - UnderlyingType->isVariablyModifiedType(), - BaseType->containsUnexpandedParameterPack()) - , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) -{} - TagDecl *TagType::getDecl() const { return getInterestingTagDecl(decl); } diff --git a/clang/test/Modules/Inputs/PR26014/A.h b/clang/test/Modules/Inputs/PR26014/A.h new file mode 100644 index 0000000..49de5ba --- /dev/null +++ b/clang/test/Modules/Inputs/PR26014/A.h @@ -0,0 +1,13 @@ +#ifndef _LIBCPP_TYPE_TRAITS +#define _LIBCPP_TYPE_TRAITS + + +template +struct underlying_type +{ + typedef __underlying_type(_Tp) type; +}; + +#endif // _LIBCPP_TYPE_TRAITS + +#include "B.h" diff --git a/clang/test/Modules/Inputs/PR26014/B.h b/clang/test/Modules/Inputs/PR26014/B.h new file mode 100644 index 0000000..58d1f8f --- /dev/null +++ b/clang/test/Modules/Inputs/PR26014/B.h @@ -0,0 +1,10 @@ +#ifndef _LIBCPP_TYPE_TRAITS +#define _LIBCPP_TYPE_TRAITS + +template +struct underlying_type +{ + typedef __underlying_type(_Tp) type; +}; + +#endif // _LIBCPP_TYPE_TRAITS diff --git a/clang/test/Modules/Inputs/PR26014/module.modulemap b/clang/test/Modules/Inputs/PR26014/module.modulemap new file mode 100644 index 0000000..4937418 --- /dev/null +++ b/clang/test/Modules/Inputs/PR26014/module.modulemap @@ -0,0 +1,9 @@ +module A { + header "A.h" + export * +} + +module B { + header "B.h" + export * +} diff --git a/clang/test/Modules/pr26014.cpp b/clang/test/Modules/pr26014.cpp new file mode 100644 index 0000000..f9ebd4e --- /dev/null +++ b/clang/test/Modules/pr26014.cpp @@ -0,0 +1,7 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -I%S/Inputs/PR26014 -verify %s +// RUN: %clang_cc1 -fmodules -fmodule-map-file=%S/Inputs/PR26014/module.modulemap -fmodules-cache-path=%t -I%S/Inputs/PR26014 -verify %s + +#include "A.h" + +// expected-no-diagnostics diff --git a/clang/test/SemaCXX/underlying_type.cpp b/clang/test/SemaCXX/underlying_type.cpp index 61208c7..dd019ae 100644 --- a/clang/test/SemaCXX/underlying_type.cpp +++ b/clang/test/SemaCXX/underlying_type.cpp @@ -55,3 +55,10 @@ namespace PR19966 { // expected-error@-2 {{constant expression}} }; } + +template void f(__underlying_type(T)); +template void f(__underlying_type(T)); +enum E {}; +void PR26014() { f(0); } // should not yield an ambiguity error. + +template void f(__underlying_type(T) v); // expected-error {{declaration type contains unexpanded parameter pack 'T'}}