diff options
Diffstat (limited to 'include/clang/AST/ASTContext.h')
| -rw-r--r-- | include/clang/AST/ASTContext.h | 394 |
1 files changed, 258 insertions, 136 deletions
diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index 703f588c5663..a5d080035df0 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -1,4 +1,4 @@ -//===--- ASTContext.h - Context to hold long-lived AST nodes ----*- C++ -*-===// +//===- ASTContext.h - Context to hold long-lived AST nodes ------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -6,10 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -/// +// /// \file /// \brief Defines the clang::ASTContext interface. -/// +// //===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_AST_ASTCONTEXT_H @@ -19,8 +19,8 @@ #include "clang/AST/CanonicalType.h" #include "clang/AST/CommentCommandTraits.h" #include "clang/AST/Decl.h" -#include "clang/AST/DeclarationName.h" #include "clang/AST/DeclBase.h" +#include "clang/AST/DeclarationName.h" #include "clang/AST/ExternalASTSource.h" #include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/PrettyPrinter.h" @@ -30,32 +30,32 @@ #include "clang/AST/Type.h" #include "clang/Basic/AddressSpaces.h" #include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/Linkage.h" -#include "clang/Basic/LLVM.h" -#include "clang/Basic/Module.h" #include "clang/Basic/OperatorKinds.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SanitizerBlacklist.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" +#include "clang/Basic/TargetInfo.h" #include "clang/Basic/XRayLists.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" -#include "llvm/ADT/iterator_range.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/None.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerUnion.h" -#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/TinyPtrVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" +#include "llvm/ADT/TinyPtrVector.h" +#include "llvm/ADT/Triple.h" +#include "llvm/ADT/iterator_range.h" #include "llvm/Support/AlignOf.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" @@ -65,7 +65,6 @@ #include <cstdint> #include <iterator> #include <memory> -#include <new> #include <string> #include <type_traits> #include <utility> @@ -75,50 +74,72 @@ namespace llvm { struct fltSemantics; -} // end namespace llvm +} // namespace llvm namespace clang { +class APValue; class ASTMutationListener; class ASTRecordLayout; class AtomicExpr; class BlockExpr; +class BuiltinTemplateDecl; class CharUnits; class CXXABI; +class CXXConstructorDecl; +class CXXMethodDecl; +class CXXRecordDecl; class DiagnosticsEngine; class Expr; +class MangleContext; class MangleNumberingContext; class MaterializeTemporaryExpr; -class TargetInfo; -// Decls -class MangleContext; +class MemberSpecializationInfo; +class Module; +class ObjCCategoryDecl; +class ObjCCategoryImplDecl; +class ObjCContainerDecl; +class ObjCImplDecl; +class ObjCImplementationDecl; +class ObjCInterfaceDecl; class ObjCIvarDecl; +class ObjCMethodDecl; class ObjCPropertyDecl; +class ObjCPropertyImplDecl; +class ObjCProtocolDecl; +class ObjCTypeParamDecl; +class Preprocessor; +class Stmt; +class StoredDeclsMap; +class TemplateDecl; +class TemplateParameterList; +class TemplateTemplateParmDecl; +class TemplateTypeParmDecl; class UnresolvedSetIterator; -class UsingDecl; class UsingShadowDecl; +class VarTemplateDecl; class VTableContextBase; namespace Builtin { - class Context; +class Context; -} // end namespace Builtin +} // namespace Builtin enum BuiltinTemplateKind : int; namespace comments { - class FullComment; +class FullComment; -} // end namespace comments +} // namespace comments struct TypeInfo { - uint64_t Width; - unsigned Align; + uint64_t Width = 0; + unsigned Align = 0; bool AlignIsRequired : 1; - TypeInfo() : Width(0), Align(0), AlignIsRequired(false) {} + TypeInfo() : AlignIsRequired(false) {} TypeInfo(uint64_t Width, unsigned Align, bool AlignIsRequired) : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {} }; @@ -126,7 +147,7 @@ struct TypeInfo { /// \brief Holds long-lived AST nodes (such as types and decls) that can be /// referred to throughout the semantic analysis of a file. class ASTContext : public RefCountedBase<ASTContext> { - ASTContext &this_() { return *this; } + friend class NestedNameSpecifier; mutable SmallVector<Type *, 0> Types; mutable llvm::FoldingSet<ExtQuals> ExtQualNodes; @@ -143,6 +164,8 @@ class ASTContext : public RefCountedBase<ASTContext> { mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes; mutable llvm::FoldingSet<DependentSizedExtVectorType> DependentSizedExtVectorTypes; + mutable llvm::FoldingSet<DependentAddressSpaceType> + DependentAddressSpaceTypes; mutable llvm::FoldingSet<VectorType> VectorTypes; mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes; mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&> @@ -187,8 +210,7 @@ class ASTContext : public RefCountedBase<ASTContext> { /// /// This set is managed by the NestedNameSpecifier class. mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers; - mutable NestedNameSpecifier *GlobalNestedNameSpecifier; - friend class NestedNameSpecifier; + mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr; /// \brief A cache mapping from RecordDecls to ASTRecordLayouts. /// @@ -199,7 +221,7 @@ class ASTContext : public RefCountedBase<ASTContext> { ObjCLayouts; /// \brief A cache from types to size and alignment information. - typedef llvm::DenseMap<const Type *, struct TypeInfo> TypeInfoMap; + using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>; mutable TypeInfoMap MemoizedTypeInfo; /// \brief A cache mapping from CXXRecordDecls to key functions. @@ -233,7 +255,7 @@ class ASTContext : public RefCountedBase<ASTContext> { public: CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm) - : Parm(Parm) { } + : Parm(Parm) {} TemplateTemplateParmDecl *getParam() const { return Parm; } @@ -249,32 +271,32 @@ class ASTContext : public RefCountedBase<ASTContext> { getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const; /// \brief The typedef for the __int128_t type. - mutable TypedefDecl *Int128Decl; + mutable TypedefDecl *Int128Decl = nullptr; /// \brief The typedef for the __uint128_t type. - mutable TypedefDecl *UInt128Decl; + mutable TypedefDecl *UInt128Decl = nullptr; /// \brief The typedef for the target specific predefined /// __builtin_va_list type. - mutable TypedefDecl *BuiltinVaListDecl; + mutable TypedefDecl *BuiltinVaListDecl = nullptr; /// The typedef for the predefined \c __builtin_ms_va_list type. - mutable TypedefDecl *BuiltinMSVaListDecl; + mutable TypedefDecl *BuiltinMSVaListDecl = nullptr; /// \brief The typedef for the predefined \c id type. - mutable TypedefDecl *ObjCIdDecl; + mutable TypedefDecl *ObjCIdDecl = nullptr; /// \brief The typedef for the predefined \c SEL type. - mutable TypedefDecl *ObjCSelDecl; + mutable TypedefDecl *ObjCSelDecl = nullptr; /// \brief The typedef for the predefined \c Class type. - mutable TypedefDecl *ObjCClassDecl; + mutable TypedefDecl *ObjCClassDecl = nullptr; /// \brief The typedef for the predefined \c Protocol class in Objective-C. - mutable ObjCInterfaceDecl *ObjCProtocolClassDecl; + mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr; /// \brief The typedef for the predefined 'BOOL' type. - mutable TypedefDecl *BOOLDecl; + mutable TypedefDecl *BOOLDecl = nullptr; // Typedefs which may be provided defining the structure of Objective-C // pseudo-builtins @@ -298,42 +320,42 @@ class ASTContext : public RefCountedBase<ASTContext> { mutable IdentifierInfo *TypePackElementName = nullptr; QualType ObjCConstantStringType; - mutable RecordDecl *CFConstantStringTagDecl; - mutable TypedefDecl *CFConstantStringTypeDecl; + mutable RecordDecl *CFConstantStringTagDecl = nullptr; + mutable TypedefDecl *CFConstantStringTypeDecl = nullptr; mutable QualType ObjCSuperType; QualType ObjCNSStringType; /// \brief The typedef declaration for the Objective-C "instancetype" type. - TypedefDecl *ObjCInstanceTypeDecl; + TypedefDecl *ObjCInstanceTypeDecl = nullptr; /// \brief The type for the C FILE type. - TypeDecl *FILEDecl; + TypeDecl *FILEDecl = nullptr; /// \brief The type for the C jmp_buf type. - TypeDecl *jmp_bufDecl; + TypeDecl *jmp_bufDecl = nullptr; /// \brief The type for the C sigjmp_buf type. - TypeDecl *sigjmp_bufDecl; + TypeDecl *sigjmp_bufDecl = nullptr; /// \brief The type for the C ucontext_t type. - TypeDecl *ucontext_tDecl; + TypeDecl *ucontext_tDecl = nullptr; /// \brief Type for the Block descriptor for Blocks CodeGen. /// /// Since this is only used for generation of debug info, it is not /// serialized. - mutable RecordDecl *BlockDescriptorType; + mutable RecordDecl *BlockDescriptorType = nullptr; /// \brief Type for the Block descriptor for Blocks CodeGen. /// /// Since this is only used for generation of debug info, it is not /// serialized. - mutable RecordDecl *BlockDescriptorExtendedType; + mutable RecordDecl *BlockDescriptorExtendedType = nullptr; /// \brief Declaration for the CUDA cudaConfigureCall function. - FunctionDecl *cudaConfigureCallDecl; + FunctionDecl *cudaConfigureCallDecl = nullptr; /// \brief Keeps track of all declaration attributes. /// @@ -363,12 +385,19 @@ class ASTContext : public RefCountedBase<ASTContext> { }; llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers; + ASTContext &this_() { return *this; } + public: /// \brief A type synonym for the TemplateOrInstantiation mapping. - typedef llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *> - TemplateOrSpecializationInfo; + using TemplateOrSpecializationInfo = + llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>; private: + friend class ASTDeclReader; + friend class ASTReader; + friend class ASTWriter; + friend class CXXRecordDecl; + /// \brief A mapping to contain the template or declaration that /// a variable declaration describes or was instantiated from, /// respectively. @@ -438,7 +467,7 @@ private: /// Since most C++ member functions aren't virtual and therefore /// don't override anything, we store the overridden functions in /// this map on the side rather than within the CXXMethodDecl structure. - typedef llvm::TinyPtrVector<const CXXMethodDecl*> CXXMethodVector; + using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>; llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods; /// \brief Mapping from each declaration context to its corresponding @@ -454,18 +483,18 @@ private: /// \brief Mapping that stores parameterIndex values for ParmVarDecls when /// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex. - typedef llvm::DenseMap<const VarDecl *, unsigned> ParameterIndexTable; + using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>; ParameterIndexTable ParamIndices; - ImportDecl *FirstLocalImport; - ImportDecl *LastLocalImport; + ImportDecl *FirstLocalImport = nullptr; + ImportDecl *LastLocalImport = nullptr; TranslationUnitDecl *TUDecl; - mutable ExternCContextDecl *ExternCContext; - mutable BuiltinTemplateDecl *MakeIntegerSeqDecl; - mutable BuiltinTemplateDecl *TypePackElementDecl; + mutable ExternCContextDecl *ExternCContext = nullptr; + mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr; + mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr; - /// \brief The associated SourceManager object.a + /// \brief The associated SourceManager object. SourceManager &SourceMgr; /// \brief The language options used to create the AST associated with @@ -494,19 +523,14 @@ private: CXXABI *createCXXABI(const TargetInfo &T); /// \brief The logical -> physical address space map. - const LangAS::Map *AddrSpaceMap; + const LangASMap *AddrSpaceMap = nullptr; /// \brief Address space map mangling must be used with language specific /// address spaces (e.g. OpenCL/CUDA) bool AddrSpaceMapMangling; - friend class ASTDeclReader; - friend class ASTReader; - friend class ASTWriter; - friend class CXXRecordDecl; - - const TargetInfo *Target; - const TargetInfo *AuxTarget; + const TargetInfo *Target = nullptr; + const TargetInfo *AuxTarget = nullptr; clang::PrintingPolicy PrintingPolicy; public: @@ -515,31 +539,33 @@ public: Builtin::Context &BuiltinInfo; mutable DeclarationNameTable DeclarationNames; IntrusiveRefCntPtr<ExternalASTSource> ExternalSource; - ASTMutationListener *Listener; + ASTMutationListener *Listener = nullptr; /// \brief Contains parents of a node. - typedef llvm::SmallVector<ast_type_traits::DynTypedNode, 2> ParentVector; + using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>; /// \brief Maps from a node to its parents. This is used for nodes that have /// pointer identity only, which are more common and we can save space by /// only storing a unique pointer to them. - typedef llvm::DenseMap<const void *, - llvm::PointerUnion4<const Decl *, const Stmt *, - ast_type_traits::DynTypedNode *, - ParentVector *>> ParentMapPointers; + using ParentMapPointers = + llvm::DenseMap<const void *, + llvm::PointerUnion4<const Decl *, const Stmt *, + ast_type_traits::DynTypedNode *, + ParentVector *>>; /// Parent map for nodes without pointer identity. We store a full /// DynTypedNode for all keys. - typedef llvm::DenseMap< - ast_type_traits::DynTypedNode, - llvm::PointerUnion4<const Decl *, const Stmt *, - ast_type_traits::DynTypedNode *, ParentVector *>> - ParentMapOtherNodes; + using ParentMapOtherNodes = + llvm::DenseMap<ast_type_traits::DynTypedNode, + llvm::PointerUnion4<const Decl *, const Stmt *, + ast_type_traits::DynTypedNode *, + ParentVector *>>; /// Container for either a single DynTypedNode or for an ArrayRef to /// DynTypedNode. For use with ParentMap. class DynTypedNodeList { - typedef ast_type_traits::DynTypedNode DynTypedNode; + using DynTypedNode = ast_type_traits::DynTypedNode; + llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode, ArrayRef<DynTypedNode>> Storage; bool IsSingleNode; @@ -548,6 +574,7 @@ public: DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) { new (Storage.buffer) DynTypedNode(N); } + DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) { new (Storage.buffer) ArrayRef<DynTypedNode>(A); } @@ -626,13 +653,14 @@ public: template <typename T> T *Allocate(size_t Num = 1) const { return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T))); } - void Deallocate(void *Ptr) const { } + void Deallocate(void *Ptr) const {} /// Return the total amount of physical memory allocated for representing /// AST nodes and type information. size_t getASTAllocatedMemory() const { return BumpAlloc.getTotalMemory(); } + /// Return the total memory used for various side tables. size_t getSideTableAllocatedMemory() const; @@ -649,6 +677,7 @@ public: /// Returns empty type if there is no appropriate target types. QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const; + /// getRealTypeForBitwidth - /// sets floating point QualTy according to specified bitwidth. /// Returns empty type if there is no appropriate target types. @@ -676,7 +705,7 @@ public: RawCommentList Comments; /// \brief True if comments are already loaded from ExternalASTSource. - mutable bool CommentsLoaded; + mutable bool CommentsLoaded = false; class RawCommentAndCacheFlags { public: @@ -759,24 +788,24 @@ public: } /// \brief Return the documentation comment attached to a given declaration. - /// Returns NULL if no comment is attached. + /// Returns nullptr if no comment is attached. /// - /// \param OriginalDecl if not NULL, is set to declaration AST node that had - /// the comment, if the comment we found comes from a redeclaration. + /// \param OriginalDecl if not nullptr, is set to declaration AST node that + /// had the comment, if the comment we found comes from a redeclaration. const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl = nullptr) const; /// Return parsed documentation comment attached to a given declaration. - /// Returns NULL if no comment is attached. + /// Returns nullptr if no comment is attached. /// - /// \param PP the Preprocessor used with this TU. Could be NULL if + /// \param PP the Preprocessor used with this TU. Could be nullptr if /// preprocessor is not available. comments::FullComment *getCommentForDecl(const Decl *D, const Preprocessor *PP) const; /// Return parsed documentation comment attached to a given declaration. - /// Returns NULL if no comment is attached. Does not look at any + /// Returns nullptr if no comment is attached. Does not look at any /// redeclarations of the declaration. comments::FullComment *getLocalCommentForDeclUncached(const Decl *D) const; @@ -788,16 +817,16 @@ private: /// \brief Iterator that visits import declarations. class import_iterator { - ImportDecl *Import; + ImportDecl *Import = nullptr; public: - typedef ImportDecl *value_type; - typedef ImportDecl *reference; - typedef ImportDecl *pointer; - typedef int difference_type; - typedef std::forward_iterator_tag iterator_category; + using value_type = ImportDecl *; + using reference = ImportDecl *; + using pointer = ImportDecl *; + using difference_type = int; + using iterator_category = std::forward_iterator_tag; - import_iterator() : Import() {} + import_iterator() = default; explicit import_iterator(ImportDecl *Import) : Import(Import) {} reference operator*() const { return Import; } @@ -876,7 +905,7 @@ public: void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl); // Access to the set of methods overridden by the given C++ method. - typedef CXXMethodVector::const_iterator overridden_cxx_method_iterator; + using overridden_cxx_method_iterator = CXXMethodVector::const_iterator; overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const; @@ -884,8 +913,10 @@ public: overridden_methods_end(const CXXMethodDecl *Method) const; unsigned overridden_methods_size(const CXXMethodDecl *Method) const; - typedef llvm::iterator_range<overridden_cxx_method_iterator> - overridden_method_range; + + using overridden_method_range = + llvm::iterator_range<overridden_cxx_method_iterator>; + overridden_method_range overridden_methods(const CXXMethodDecl *Method) const; /// \brief Note that the given C++ \p Method overrides the given \p @@ -912,7 +943,8 @@ public: return Import->NextLocalImport; } - typedef llvm::iterator_range<import_iterator> import_range; + using import_range = llvm::iterator_range<import_iterator>; + import_range local_imports() const { return import_range(import_iterator(FirstLocalImport), import_iterator()); } @@ -929,6 +961,7 @@ public: /// and should be visible whenever \p M is visible. void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners = true); + /// \brief Clean up the merged definition list. Call this if you might have /// added duplicates into the list. void deduplicateMergedDefinitonsFor(NamedDecl *ND); @@ -973,6 +1006,7 @@ public: CanQualType UnsignedLongLongTy, UnsignedInt128Ty; CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty; CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON + CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3 CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy; CanQualType Float128ComplexTy; CanQualType VoidPtrTy, NullPtrTy; @@ -1067,7 +1101,14 @@ public: /// The resulting type has a union of the qualifiers from T and the address /// space. If T already has an address space specifier, it is silently /// replaced. - QualType getAddrSpaceQualType(QualType T, unsigned AddressSpace) const; + QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const; + + /// \brief Remove any existing address space on the type and returns the type + /// with qualifiers intact (or that's the idea anyway) + /// + /// The return type should be T with all prior qualifiers minus the address + /// space. + QualType removeAddrSpaceQualType(QualType T) const; /// \brief Apply Objective-C protocol qualifiers to the given type. /// \param allowOnPointerType specifies if we can apply protocol @@ -1175,6 +1216,7 @@ public: /// \brief Return a read_only pipe type for the specified type. QualType getReadPipeType(QualType T) const; + /// \brief Return a write_only pipe type for the specified type. QualType getWritePipeType(QualType T) const; @@ -1182,9 +1224,16 @@ public: /// pointer to blocks. QualType getBlockDescriptorExtendedType() const; + /// Map an AST Type to an OpenCLTypeKind enum value. + TargetInfo::OpenCLTypeKind getOpenCLTypeKind(const Type *T) const; + + /// Get address space for OpenCL type. + LangAS getOpenCLTypeAddrSpace(const Type *T) const; + void setcudaConfigureCallDecl(FunctionDecl *FD) { cudaConfigureCallDecl = FD; } + FunctionDecl *getcudaConfigureCallDecl() { return cudaConfigureCallDecl; } @@ -1192,7 +1241,6 @@ public: /// Returns true iff we need copy/dispose helpers for the given type. bool BlockRequiresCopying(QualType Ty, const VarDecl *D); - /// Returns true, if given type has a known lifetime. HasByrefExtendedLayout is set /// to false in this case. If HasByrefExtendedLayout returns true, byref variable /// has extended lifetime. @@ -1269,6 +1317,10 @@ public: Expr *SizeExpr, SourceLocation AttrLoc) const; + QualType getDependentAddressSpaceType(QualType PointeeType, + Expr *AddrSpaceExpr, + SourceLocation AttrLoc) const; + /// \brief Return a K&R style C function type like 'int()'. QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const; @@ -1396,6 +1448,7 @@ public: QualType Canonical = QualType()) const; bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl); + /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in /// QT's qualified-id protocol list adopt all protocols in IDecl's list /// of protocols. @@ -1426,7 +1479,7 @@ public: /// \brief C++11 deduction pattern for 'auto &&' type. QualType getAutoRRefDeductType() const; - /// \brief C++1z deduced class template specialization type. + /// \brief C++17 deduced class template specialization type. QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const; @@ -1488,6 +1541,11 @@ public: /// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). QualType getPointerDiffType() const; + /// \brief Return the unique unsigned counterpart of "ptrdiff_t" + /// integer type. The standard (C11 7.21.6.1p7) refers to this type + /// in the definition of %tu format specifier. + QualType getUnsignedPointerDiffType() const; + /// \brief Return the unique type for "pid_t" defined in /// <sys/types.h>. We need this to compute the correct type for vfork(). QualType getProcessIDType() const; @@ -1581,6 +1639,24 @@ public: return NSCopyingName; } + CanQualType getNSUIntegerType() const { + assert(Target && "Expected target to be initialized"); + const llvm::Triple &T = Target->getTriple(); + // Windows is LLP64 rather than LP64 + if (T.isOSWindows() && T.isArch64Bit()) + return UnsignedLongLongTy; + return UnsignedLongTy; + } + + CanQualType getNSIntegerType() const { + assert(Target && "Expected target to be initialized"); + const llvm::Triple &T = Target->getTriple(); + // Windows is LLP64 rather than LP64 + if (T.isOSWindows() && T.isArch64Bit()) + return LongLongTy; + return LongTy; + } + /// Retrieve the identifier 'bool'. IdentifierInfo *getBoolName() const { if (!BoolName) @@ -1865,10 +1941,17 @@ public: const TemplateArgument &ArgPack) const; enum GetBuiltinTypeError { - GE_None, ///< No error - GE_Missing_stdio, ///< Missing a type from <stdio.h> - GE_Missing_setjmp, ///< Missing a type from <setjmp.h> - GE_Missing_ucontext ///< Missing a type from <ucontext.h> + /// No error + GE_None, + + /// Missing a type from <stdio.h> + GE_Missing_stdio, + + /// Missing a type from <setjmp.h> + GE_Missing_setjmp, + + /// Missing a type from <ucontext.h> + GE_Missing_ucontext }; /// \brief Return the type for the specified builtin. @@ -2019,7 +2102,7 @@ public: getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const; /// \brief Get our current best idea for the key function of the - /// given record decl, or NULL if there isn't one. + /// given record decl, or nullptr if there isn't one. /// /// The key function is, according to the Itanium C++ ABI section 5.2.3: /// ...the first non-pure virtual function that is not inline at the @@ -2072,6 +2155,10 @@ public: void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols); + /// \brief Return true if the specified type has unique object representations + /// according to (C++17 [meta.unary.prop]p9) + bool hasUniqueObjectRepresentations(QualType Ty) const; + //===--------------------------------------------------------------------===// // Type Operators //===--------------------------------------------------------------------===// @@ -2103,7 +2190,6 @@ public: bool hasSameType(QualType T1, QualType T2) const { return getCanonicalType(T1) == getCanonicalType(T2); } - bool hasSameType(const Type *T1, const Type *T2) const { return getCanonicalType(T1) == getCanonicalType(T2); } @@ -2192,7 +2278,7 @@ public: getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const; /// \brief Retrieves the default calling convention for the current target. - CallingConv getDefaultCallingConvention(bool isVariadic, + CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const; /// \brief Retrieves the "canonical" template name that refers to a @@ -2326,14 +2412,14 @@ public: return getTargetAddressSpace(Q.getAddressSpace()); } - unsigned getTargetAddressSpace(unsigned AS) const; + unsigned getTargetAddressSpace(LangAS AS) const; /// Get target-dependent integer value for null pointer which is used for /// constant folding. uint64_t getTargetNullPointerValue(QualType QT) const; - bool addressSpaceMapManglingFor(unsigned AS) const { - return AddrSpaceMapMangling || AS >= LangAS::FirstTargetAddressSpace; + bool addressSpaceMapManglingFor(LangAS AS) const { + return AddrSpaceMapMangling || isTargetAddressSpace(AS); } private: @@ -2355,12 +2441,15 @@ public: bool isObjCIdType(QualType T) const { return T == getObjCIdType(); } + bool isObjCClassType(QualType T) const { return T == getObjCClassType(); } + bool isObjCSelType(QualType T) const { return T == getObjCSelType(); } + bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare); @@ -2394,9 +2483,30 @@ public: QualType mergeObjCGCQualifiers(QualType, QualType); - bool doFunctionTypesMatchOnExtParameterInfos( - const FunctionProtoType *FromFunctionType, - const FunctionProtoType *ToFunctionType); + /// This function merges the ExtParameterInfo lists of two functions. It + /// returns true if the lists are compatible. The merged list is returned in + /// NewParamInfos. + /// + /// \param FirstFnType The type of the first function. + /// + /// \param SecondFnType The type of the second function. + /// + /// \param CanUseFirst This flag is set to true if the first function's + /// ExtParameterInfo list can be used as the composite list of + /// ExtParameterInfo. + /// + /// \param CanUseSecond This flag is set to true if the second function's + /// ExtParameterInfo list can be used as the composite list of + /// ExtParameterInfo. + /// + /// \param NewParamInfos The composite list of ExtParameterInfo. The list is + /// empty if none of the flags are set. + /// + bool mergeExtParameterInfo( + const FunctionProtoType *FirstFnType, + const FunctionProtoType *SecondFnType, + bool &CanUseFirst, bool &CanUseSecond, + SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos); void ResetObjCLayout(const ObjCContainerDecl *CD); @@ -2432,12 +2542,13 @@ public: bool isSentinelNullExpr(const Expr *E); - /// \brief Get the implementation of the ObjCInterfaceDecl \p D, or NULL if + /// \brief Get the implementation of the ObjCInterfaceDecl \p D, or nullptr if /// none exists. ObjCImplementationDecl *getObjCImplementation(ObjCInterfaceDecl *D); - /// \brief Get the implementation of the ObjCCategoryDecl \p D, or NULL if + + /// \brief Get the implementation of the ObjCCategoryDecl \p D, or nullptr if /// none exists. - ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D); + ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D); /// \brief Return true if there is at least one \@implementation in the TU. bool AnyObjCImplementation() { @@ -2447,6 +2558,7 @@ public: /// \brief Set the implementation of ObjCInterfaceDecl. void setObjCImplementation(ObjCInterfaceDecl *IFaceD, ObjCImplementationDecl *ImplD); + /// \brief Set the implementation of ObjCCategoryDecl. void setObjCImplementation(ObjCCategoryDecl *CatD, ObjCCategoryImplDecl *ImplD); @@ -2466,8 +2578,9 @@ public: /// \brief Set the copy inialization expression of a block var decl. void setBlockVarCopyInits(VarDecl*VD, Expr* Init); + /// \brief Get the copy initialization expression of the VarDecl \p VD, or - /// NULL if none exists. + /// nullptr if none exists. Expr *getBlockVarCopyInits(const VarDecl* VD); /// \brief Allocate an uninitialized TypeSourceInfo. @@ -2636,6 +2749,7 @@ private: const FieldDecl *Field, bool includeVBases = true, QualType *NotEncodedT=nullptr) const; + public: // Adds the encoding of a method parameter or return type. void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, @@ -2647,11 +2761,19 @@ public: bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const; enum class InlineVariableDefinitionKind { - None, ///< Not an inline variable. - Weak, ///< Weak definition of inline variable. - WeakUnknown, ///< Weak for now, might become strong later in this TU. - Strong ///< Strong definition. + /// Not an inline variable. + None, + + /// Weak definition of inline variable. + Weak, + + /// Weak for now, might become strong later in this TU. + WeakUnknown, + + /// Strong definition. + Strong }; + /// \brief Determine whether a definition of this inline variable should /// be treated as a weak or strong definition. For compatibility with /// C++14 and before, for a constexpr static data member, if there is an @@ -2661,6 +2783,9 @@ public: getInlineVariableDefinitionKind(const VarDecl *VD) const; private: + friend class DeclarationNameTable; + friend class DeclContext; + const ASTRecordLayout & getObjCLayout(const ObjCInterfaceDecl *D, const ObjCImplementationDecl *Impl) const; @@ -2673,26 +2798,23 @@ private: // into the datastructures which avoids this mess during deallocation but is // wasteful of memory, and here we require a lot of error prone book keeping // in order to track and run destructors while we're tearing things down. - typedef llvm::SmallVector<std::pair<void (*)(void *), void *>, 16> - DeallocationFunctionsAndArguments; + using DeallocationFunctionsAndArguments = + llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>; DeallocationFunctionsAndArguments Deallocations; // FIXME: This currently contains the set of StoredDeclMaps used // by DeclContext objects. This probably should not be in ASTContext, // but we include it here so that ASTContext can quickly deallocate them. - llvm::PointerIntPair<StoredDeclsMap*,1> LastSDM; - - friend class DeclContext; - friend class DeclarationNameTable; - - void ReleaseDeclContextMaps(); - void ReleaseParentMapEntries(); + llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM; std::unique_ptr<ParentMapPointers> PointerParents; std::unique_ptr<ParentMapOtherNodes> OtherParents; std::unique_ptr<VTableContextBase> VTContext; + void ReleaseDeclContextMaps(); + void ReleaseParentMapEntries(); + public: enum PragmaSectionFlag : unsigned { PSF_None = 0, @@ -2712,27 +2834,26 @@ public: SectionInfo(DeclaratorDecl *Decl, SourceLocation PragmaSectionLocation, int SectionFlags) - : Decl(Decl), - PragmaSectionLocation(PragmaSectionLocation), - SectionFlags(SectionFlags) {} + : Decl(Decl), PragmaSectionLocation(PragmaSectionLocation), + SectionFlags(SectionFlags) {} }; llvm::StringMap<SectionInfo> SectionInfos; }; /// \brief Utility function for constructing a nullary selector. -static inline Selector GetNullarySelector(StringRef name, ASTContext& Ctx) { +inline Selector GetNullarySelector(StringRef name, ASTContext &Ctx) { IdentifierInfo* II = &Ctx.Idents.get(name); return Ctx.Selectors.getSelector(0, &II); } /// \brief Utility function for constructing an unary selector. -static inline Selector GetUnarySelector(StringRef name, ASTContext& Ctx) { +inline Selector GetUnarySelector(StringRef name, ASTContext &Ctx) { IdentifierInfo* II = &Ctx.Idents.get(name); return Ctx.Selectors.getSelector(1, &II); } -} // end namespace clang +} // namespace clang // operator new and delete aren't allowed inside namespaces. @@ -2763,11 +2884,12 @@ static inline Selector GetUnarySelector(StringRef name, ASTContext& Ctx) { /// @param C The ASTContext that provides the allocator. /// @param Alignment The alignment of the allocated memory (if the underlying /// allocator supports it). -/// @return The allocated memory. Could be NULL. +/// @return The allocated memory. Could be nullptr. inline void *operator new(size_t Bytes, const clang::ASTContext &C, size_t Alignment) { return C.Allocate(Bytes, Alignment); } + /// @brief Placement delete companion to the new above. /// /// This operator is just a companion to the new above. There is no way of @@ -2800,7 +2922,7 @@ inline void operator delete(void *Ptr, const clang::ASTContext &C, size_t) { /// @param C The ASTContext that provides the allocator. /// @param Alignment The alignment of the allocated memory (if the underlying /// allocator supports it). -/// @return The allocated memory. Could be NULL. +/// @return The allocated memory. Could be nullptr. inline void *operator new[](size_t Bytes, const clang::ASTContext& C, size_t Alignment = 8) { return C.Allocate(Bytes, Alignment); |