| //===- ASTContext.cpp - Context to hold long-lived AST nodes --------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the ASTContext interface. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/ASTContext.h" |
| #include "CXXABI.h" |
| #include "Interp/Context.h" |
| #include "clang/AST/APValue.h" |
| #include "clang/AST/ASTMutationListener.h" |
| #include "clang/AST/ASTTypeTraits.h" |
| #include "clang/AST/Attr.h" |
| #include "clang/AST/AttrIterator.h" |
| #include "clang/AST/CharUnits.h" |
| #include "clang/AST/Comment.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclBase.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclContextInternals.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/DeclOpenMP.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/DeclarationName.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/AST/ExternalASTSource.h" |
| #include "clang/AST/Mangle.h" |
| #include "clang/AST/MangleNumberingContext.h" |
| #include "clang/AST/NestedNameSpecifier.h" |
| #include "clang/AST/RawCommentList.h" |
| #include "clang/AST/RecordLayout.h" |
| #include "clang/AST/RecursiveASTVisitor.h" |
| #include "clang/AST/Stmt.h" |
| #include "clang/AST/TemplateBase.h" |
| #include "clang/AST/TemplateName.h" |
| #include "clang/AST/Type.h" |
| #include "clang/AST/TypeLoc.h" |
| #include "clang/AST/UnresolvedSet.h" |
| #include "clang/AST/VTableBuilder.h" |
| #include "clang/Basic/AddressSpaces.h" |
| #include "clang/Basic/Builtins.h" |
| #include "clang/Basic/CommentOptions.h" |
| #include "clang/Basic/ExceptionSpecificationType.h" |
| #include "clang/Basic/FixedPoint.h" |
| #include "clang/Basic/IdentifierTable.h" |
| #include "clang/Basic/LLVM.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/Basic/Linkage.h" |
| #include "clang/Basic/ObjCRuntime.h" |
| #include "clang/Basic/SanitizerBlacklist.h" |
| #include "clang/Basic/SourceLocation.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "clang/Basic/Specifiers.h" |
| #include "clang/Basic/TargetCXXABI.h" |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/Basic/XRayLists.h" |
| #include "llvm/ADT/APInt.h" |
| #include "llvm/ADT/APSInt.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/DenseMap.h" |
| #include "llvm/ADT/DenseSet.h" |
| #include "llvm/ADT/FoldingSet.h" |
| #include "llvm/ADT/None.h" |
| #include "llvm/ADT/Optional.h" |
| #include "llvm/ADT/PointerUnion.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/Triple.h" |
| #include "llvm/Support/Capacity.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/Compiler.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/MathExtras.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <algorithm> |
| #include <cassert> |
| #include <cstddef> |
| #include <cstdint> |
| #include <cstdlib> |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <tuple> |
| #include <utility> |
| |
| using namespace clang; |
| |
| enum FloatingRank { |
| Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank |
| }; |
| |
| /// \returns location that is relevant when searching for Doc comments related |
| /// to \p D. |
| static SourceLocation getDeclLocForCommentSearch(const Decl *D, |
| SourceManager &SourceMgr) { |
| assert(D); |
| |
| // User can not attach documentation to implicit declarations. |
| if (D->isImplicit()) |
| return {}; |
| |
| // User can not attach documentation to implicit instantiations. |
| if (const auto *FD = dyn_cast<FunctionDecl>(D)) { |
| if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) |
| return {}; |
| } |
| |
| if (const auto *VD = dyn_cast<VarDecl>(D)) { |
| if (VD->isStaticDataMember() && |
| VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) |
| return {}; |
| } |
| |
| if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) { |
| if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) |
| return {}; |
| } |
| |
| if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { |
| TemplateSpecializationKind TSK = CTSD->getSpecializationKind(); |
| if (TSK == TSK_ImplicitInstantiation || |
| TSK == TSK_Undeclared) |
| return {}; |
| } |
| |
| if (const auto *ED = dyn_cast<EnumDecl>(D)) { |
| if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) |
| return {}; |
| } |
| if (const auto *TD = dyn_cast<TagDecl>(D)) { |
| // When tag declaration (but not definition!) is part of the |
| // decl-specifier-seq of some other declaration, it doesn't get comment |
| if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition()) |
| return {}; |
| } |
| // TODO: handle comments for function parameters properly. |
| if (isa<ParmVarDecl>(D)) |
| return {}; |
| |
| // TODO: we could look up template parameter documentation in the template |
| // documentation. |
| if (isa<TemplateTypeParmDecl>(D) || |
| isa<NonTypeTemplateParmDecl>(D) || |
| isa<TemplateTemplateParmDecl>(D)) |
| return {}; |
| |
| // Find declaration location. |
| // For Objective-C declarations we generally don't expect to have multiple |
| // declarators, thus use declaration starting location as the "declaration |
| // location". |
| // For all other declarations multiple declarators are used quite frequently, |
| // so we use the location of the identifier as the "declaration location". |
| if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) || |
| isa<ObjCPropertyDecl>(D) || |
| isa<RedeclarableTemplateDecl>(D) || |
| isa<ClassTemplateSpecializationDecl>(D)) |
| return D->getBeginLoc(); |
| else { |
| const SourceLocation DeclLoc = D->getLocation(); |
| if (DeclLoc.isMacroID()) { |
| if (isa<TypedefDecl>(D)) { |
| // If location of the typedef name is in a macro, it is because being |
| // declared via a macro. Try using declaration's starting location as |
| // the "declaration location". |
| return D->getBeginLoc(); |
| } else if (const auto *TD = dyn_cast<TagDecl>(D)) { |
| // If location of the tag decl is inside a macro, but the spelling of |
| // the tag name comes from a macro argument, it looks like a special |
| // macro like NS_ENUM is being used to define the tag decl. In that |
| // case, adjust the source location to the expansion loc so that we can |
| // attach the comment to the tag decl. |
| if (SourceMgr.isMacroArgExpansion(DeclLoc) && |
| TD->isCompleteDefinition()) |
| return SourceMgr.getExpansionLoc(DeclLoc); |
| } |
| } |
| return DeclLoc; |
| } |
| |
| return {}; |
| } |
| |
| RawComment *ASTContext::getRawCommentForDeclNoCacheImpl( |
| const Decl *D, const SourceLocation RepresentativeLocForDecl, |
| const std::map<unsigned, RawComment *> &CommentsInTheFile) const { |
| // If the declaration doesn't map directly to a location in a file, we |
| // can't find the comment. |
| if (RepresentativeLocForDecl.isInvalid() || |
| !RepresentativeLocForDecl.isFileID()) |
| return nullptr; |
| |
| // If there are no comments anywhere, we won't find anything. |
| if (CommentsInTheFile.empty()) |
| return nullptr; |
| |
| // Decompose the location for the declaration and find the beginning of the |
| // file buffer. |
| const std::pair<FileID, unsigned> DeclLocDecomp = |
| SourceMgr.getDecomposedLoc(RepresentativeLocForDecl); |
| |
| // Slow path. |
| auto OffsetCommentBehindDecl = |
| CommentsInTheFile.lower_bound(DeclLocDecomp.second); |
| |
| // First check whether we have a trailing comment. |
| if (OffsetCommentBehindDecl != CommentsInTheFile.end()) { |
| RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second; |
| if ((CommentBehindDecl->isDocumentation() || |
| LangOpts.CommentOpts.ParseAllComments) && |
| CommentBehindDecl->isTrailingComment() && |
| (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) || |
| isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) { |
| |
| // Check that Doxygen trailing comment comes after the declaration, starts |
| // on the same line and in the same file as the declaration. |
| if (SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) == |
| Comments.getCommentBeginLine(CommentBehindDecl, DeclLocDecomp.first, |
| OffsetCommentBehindDecl->first)) { |
| return CommentBehindDecl; |
| } |
| } |
| } |
| |
| // The comment just after the declaration was not a trailing comment. |
| // Let's look at the previous comment. |
| if (OffsetCommentBehindDecl == CommentsInTheFile.begin()) |
| return nullptr; |
| |
| auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl; |
| RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second; |
| |
| // Check that we actually have a non-member Doxygen comment. |
| if (!(CommentBeforeDecl->isDocumentation() || |
| LangOpts.CommentOpts.ParseAllComments) || |
| CommentBeforeDecl->isTrailingComment()) |
| return nullptr; |
| |
| // Decompose the end of the comment. |
| const unsigned CommentEndOffset = |
| Comments.getCommentEndOffset(CommentBeforeDecl); |
| |
| // Get the corresponding buffer. |
| bool Invalid = false; |
| const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first, |
| &Invalid).data(); |
| if (Invalid) |
| return nullptr; |
| |
| // Extract text between the comment and declaration. |
| StringRef Text(Buffer + CommentEndOffset, |
| DeclLocDecomp.second - CommentEndOffset); |
| |
| // There should be no other declarations or preprocessor directives between |
| // comment and declaration. |
| if (Text.find_first_of(";{}#@") != StringRef::npos) |
| return nullptr; |
| |
| return CommentBeforeDecl; |
| } |
| |
| RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const { |
| const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr); |
| |
| // If the declaration doesn't map directly to a location in a file, we |
| // can't find the comment. |
| if (DeclLoc.isInvalid() || !DeclLoc.isFileID()) |
| return nullptr; |
| |
| if (ExternalSource && !CommentsLoaded) { |
| ExternalSource->ReadComments(); |
| CommentsLoaded = true; |
| } |
| |
| if (Comments.empty()) |
| return nullptr; |
| |
| const FileID File = SourceMgr.getDecomposedLoc(DeclLoc).first; |
| const auto CommentsInThisFile = Comments.getCommentsInFile(File); |
| if (!CommentsInThisFile || CommentsInThisFile->empty()) |
| return nullptr; |
| |
| return getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile); |
| } |
| |
| /// If we have a 'templated' declaration for a template, adjust 'D' to |
| /// refer to the actual template. |
| /// If we have an implicit instantiation, adjust 'D' to refer to template. |
| static const Decl &adjustDeclToTemplate(const Decl &D) { |
| if (const auto *FD = dyn_cast<FunctionDecl>(&D)) { |
| // Is this function declaration part of a function template? |
| if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate()) |
| return *FTD; |
| |
| // Nothing to do if function is not an implicit instantiation. |
| if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) |
| return D; |
| |
| // Function is an implicit instantiation of a function template? |
| if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate()) |
| return *FTD; |
| |
| // Function is instantiated from a member definition of a class template? |
| if (const FunctionDecl *MemberDecl = |
| FD->getInstantiatedFromMemberFunction()) |
| return *MemberDecl; |
| |
| return D; |
| } |
| if (const auto *VD = dyn_cast<VarDecl>(&D)) { |
| // Static data member is instantiated from a member definition of a class |
| // template? |
| if (VD->isStaticDataMember()) |
| if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember()) |
| return *MemberDecl; |
| |
| return D; |
| } |
| if (const auto *CRD = dyn_cast<CXXRecordDecl>(&D)) { |
| // Is this class declaration part of a class template? |
| if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate()) |
| return *CTD; |
| |
| // Class is an implicit instantiation of a class template or partial |
| // specialization? |
| if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) { |
| if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation) |
| return D; |
| llvm::PointerUnion<ClassTemplateDecl *, |
| ClassTemplatePartialSpecializationDecl *> |
| PU = CTSD->getSpecializedTemplateOrPartial(); |
| return PU.is<ClassTemplateDecl *>() |
| ? *static_cast<const Decl *>(PU.get<ClassTemplateDecl *>()) |
| : *static_cast<const Decl *>( |
| PU.get<ClassTemplatePartialSpecializationDecl *>()); |
| } |
| |
| // Class is instantiated from a member definition of a class template? |
| if (const MemberSpecializationInfo *Info = |
| CRD->getMemberSpecializationInfo()) |
| return *Info->getInstantiatedFrom(); |
| |
| return D; |
| } |
| if (const auto *ED = dyn_cast<EnumDecl>(&D)) { |
| // Enum is instantiated from a member definition of a class template? |
| if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum()) |
| return *MemberDecl; |
| |
| return D; |
| } |
| // FIXME: Adjust alias templates? |
| return D; |
| } |
| |
| const RawComment *ASTContext::getRawCommentForAnyRedecl( |
| const Decl *D, |
| const Decl **OriginalDecl) const { |
| if (!D) { |
| if (OriginalDecl) |
| OriginalDecl = nullptr; |
| return nullptr; |
| } |
| |
| D = &adjustDeclToTemplate(*D); |
| |
| // Any comment directly attached to D? |
| { |
| auto DeclComment = DeclRawComments.find(D); |
| if (DeclComment != DeclRawComments.end()) { |
| if (OriginalDecl) |
| *OriginalDecl = D; |
| return DeclComment->second; |
| } |
| } |
| |
| // Any comment attached to any redeclaration of D? |
| const Decl *CanonicalD = D->getCanonicalDecl(); |
| if (!CanonicalD) |
| return nullptr; |
| |
| { |
| auto RedeclComment = RedeclChainComments.find(CanonicalD); |
| if (RedeclComment != RedeclChainComments.end()) { |
| if (OriginalDecl) |
| *OriginalDecl = RedeclComment->second; |
| auto CommentAtRedecl = DeclRawComments.find(RedeclComment->second); |
| assert(CommentAtRedecl != DeclRawComments.end() && |
| "This decl is supposed to have comment attached."); |
| return CommentAtRedecl->second; |
| } |
| } |
| |
| // Any redeclarations of D that we haven't checked for comments yet? |
| // We can't use DenseMap::iterator directly since it'd get invalid. |
| auto LastCheckedRedecl = [this, CanonicalD]() -> const Decl * { |
| auto LookupRes = CommentlessRedeclChains.find(CanonicalD); |
| if (LookupRes != CommentlessRedeclChains.end()) |
| return LookupRes->second; |
| return nullptr; |
| }(); |
| |
| for (const auto Redecl : D->redecls()) { |
| assert(Redecl); |
| // Skip all redeclarations that have been checked previously. |
| if (LastCheckedRedecl) { |
| if (LastCheckedRedecl == Redecl) { |
| LastCheckedRedecl = nullptr; |
| } |
| continue; |
| } |
| const RawComment *RedeclComment = getRawCommentForDeclNoCache(Redecl); |
| if (RedeclComment) { |
| cacheRawCommentForDecl(*Redecl, *RedeclComment); |
| if (OriginalDecl) |
| *OriginalDecl = Redecl; |
| return RedeclComment; |
| } |
| CommentlessRedeclChains[CanonicalD] = Redecl; |
| } |
| |
| if (OriginalDecl) |
| *OriginalDecl = nullptr; |
| return nullptr; |
| } |
| |
| void ASTContext::cacheRawCommentForDecl(const Decl &OriginalD, |
| const RawComment &Comment) const { |
| assert(Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments); |
| DeclRawComments.try_emplace(&OriginalD, &Comment); |
| const Decl *const CanonicalDecl = OriginalD.getCanonicalDecl(); |
| RedeclChainComments.try_emplace(CanonicalDecl, &OriginalD); |
| CommentlessRedeclChains.erase(CanonicalDecl); |
| } |
| |
| static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, |
| SmallVectorImpl<const NamedDecl *> &Redeclared) { |
| const DeclContext *DC = ObjCMethod->getDeclContext(); |
| if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) { |
| const ObjCInterfaceDecl *ID = IMD->getClassInterface(); |
| if (!ID) |
| return; |
| // Add redeclared method here. |
| for (const auto *Ext : ID->known_extensions()) { |
| if (ObjCMethodDecl *RedeclaredMethod = |
| Ext->getMethod(ObjCMethod->getSelector(), |
| ObjCMethod->isInstanceMethod())) |
| Redeclared.push_back(RedeclaredMethod); |
| } |
| } |
| } |
| |
| void ASTContext::attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls, |
| const Preprocessor *PP) { |
| if (Comments.empty() || Decls.empty()) |
| return; |
| |
| // See if there are any new comments that are not attached to a decl. |
| // The location doesn't have to be precise - we care only about the file. |
| const FileID File = |
| SourceMgr.getDecomposedLoc((*Decls.begin())->getLocation()).first; |
| auto CommentsInThisFile = Comments.getCommentsInFile(File); |
| if (!CommentsInThisFile || CommentsInThisFile->empty() || |
| CommentsInThisFile->rbegin()->second->isAttached()) |
| return; |
| |
| // There is at least one comment not attached to a decl. |
| // Maybe it should be attached to one of Decls? |
| // |
| // Note that this way we pick up not only comments that precede the |
| // declaration, but also comments that *follow* the declaration -- thanks to |
| // the lookahead in the lexer: we've consumed the semicolon and looked |
| // ahead through comments. |
| |
| for (const Decl *D : Decls) { |
| assert(D); |
| if (D->isInvalidDecl()) |
| continue; |
| |
| D = &adjustDeclToTemplate(*D); |
| |
| const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr); |
| |
| if (DeclLoc.isInvalid() || !DeclLoc.isFileID()) |
| continue; |
| |
| if (DeclRawComments.count(D) > 0) |
| continue; |
| |
| if (RawComment *const DocComment = |
| getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile)) { |
| cacheRawCommentForDecl(*D, *DocComment); |
| comments::FullComment *FC = DocComment->parse(*this, PP, D); |
| ParsedComments[D->getCanonicalDecl()] = FC; |
| } |
| } |
| } |
| |
| comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC, |
| const Decl *D) const { |
| auto *ThisDeclInfo = new (*this) comments::DeclInfo; |
| ThisDeclInfo->CommentDecl = D; |
| ThisDeclInfo->IsFilled = false; |
| ThisDeclInfo->fill(); |
| ThisDeclInfo->CommentDecl = FC->getDecl(); |
| if (!ThisDeclInfo->TemplateParameters) |
| ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters; |
| comments::FullComment *CFC = |
| new (*this) comments::FullComment(FC->getBlocks(), |
| ThisDeclInfo); |
| return CFC; |
| } |
| |
| comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const { |
| const RawComment *RC = getRawCommentForDeclNoCache(D); |
| return RC ? RC->parse(*this, nullptr, D) : nullptr; |
| } |
| |
| comments::FullComment *ASTContext::getCommentForDecl( |
| const Decl *D, |
| const Preprocessor *PP) const { |
| if (!D || D->isInvalidDecl()) |
| return nullptr; |
| D = &adjustDeclToTemplate(*D); |
| |
| const Decl *Canonical = D->getCanonicalDecl(); |
| llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos = |
| ParsedComments.find(Canonical); |
| |
| if (Pos != ParsedComments.end()) { |
| if (Canonical != D) { |
| comments::FullComment *FC = Pos->second; |
| comments::FullComment *CFC = cloneFullComment(FC, D); |
| return CFC; |
| } |
| return Pos->second; |
| } |
| |
| const Decl *OriginalDecl = nullptr; |
| |
| const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl); |
| if (!RC) { |
| if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) { |
| SmallVector<const NamedDecl*, 8> Overridden; |
| const auto *OMD = dyn_cast<ObjCMethodDecl>(D); |
| if (OMD && OMD->isPropertyAccessor()) |
| if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl()) |
| if (comments::FullComment *FC = getCommentForDecl(PDecl, PP)) |
| return cloneFullComment(FC, D); |
| if (OMD) |
| addRedeclaredMethods(OMD, Overridden); |
| getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden); |
| for (unsigned i = 0, e = Overridden.size(); i < e; i++) |
| if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP)) |
| return cloneFullComment(FC, D); |
| } |
| else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) { |
| // Attach any tag type's documentation to its typedef if latter |
| // does not have one of its own. |
| QualType QT = TD->getUnderlyingType(); |
| if (const auto *TT = QT->getAs<TagType>()) |
| if (const Decl *TD = TT->getDecl()) |
| if (comments::FullComment *FC = getCommentForDecl(TD, PP)) |
| return cloneFullComment(FC, D); |
| } |
| else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) { |
| while (IC->getSuperClass()) { |
| IC = IC->getSuperClass(); |
| if (comments::FullComment *FC = getCommentForDecl(IC, PP)) |
| return cloneFullComment(FC, D); |
| } |
| } |
| else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) { |
| if (const ObjCInterfaceDecl *IC = CD->getClassInterface()) |
| if (comments::FullComment *FC = getCommentForDecl(IC, PP)) |
| return cloneFullComment(FC, D); |
| } |
| else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) { |
| if (!(RD = RD->getDefinition())) |
| return nullptr; |
| // Check non-virtual bases. |
| for (const auto &I : RD->bases()) { |
| if (I.isVirtual() || (I.getAccessSpecifier() != AS_public)) |
| continue; |
| QualType Ty = I.getType(); |
| if (Ty.isNull()) |
| continue; |
| if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) { |
| if (!(NonVirtualBase= NonVirtualBase->getDefinition())) |
| continue; |
| |
| if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP)) |
| return cloneFullComment(FC, D); |
| } |
| } |
| // Check virtual bases. |
| for (const auto &I : RD->vbases()) { |
| if (I.getAccessSpecifier() != AS_public) |
| continue; |
| QualType Ty = I.getType(); |
| if (Ty.isNull()) |
| continue; |
| if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) { |
| if (!(VirtualBase= VirtualBase->getDefinition())) |
| continue; |
| if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP)) |
| return cloneFullComment(FC, D); |
| } |
| } |
| } |
| return nullptr; |
| } |
| |
| // If the RawComment was attached to other redeclaration of this Decl, we |
| // should parse the comment in context of that other Decl. This is important |
| // because comments can contain references to parameter names which can be |
| // different across redeclarations. |
| if (D != OriginalDecl && OriginalDecl) |
| return getCommentForDecl(OriginalDecl, PP); |
| |
| comments::FullComment *FC = RC->parse(*this, PP, D); |
| ParsedComments[Canonical] = FC; |
| return FC; |
| } |
| |
| void |
| ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, |
| TemplateTemplateParmDecl *Parm) { |
| ID.AddInteger(Parm->getDepth()); |
| ID.AddInteger(Parm->getPosition()); |
| ID.AddBoolean(Parm->isParameterPack()); |
| |
| TemplateParameterList *Params = Parm->getTemplateParameters(); |
| ID.AddInteger(Params->size()); |
| for (TemplateParameterList::const_iterator P = Params->begin(), |
| PEnd = Params->end(); |
| P != PEnd; ++P) { |
| if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { |
| ID.AddInteger(0); |
| ID.AddBoolean(TTP->isParameterPack()); |
| continue; |
| } |
| |
| if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { |
| ID.AddInteger(1); |
| ID.AddBoolean(NTTP->isParameterPack()); |
| ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr()); |
| if (NTTP->isExpandedParameterPack()) { |
| ID.AddBoolean(true); |
| ID.AddInteger(NTTP->getNumExpansionTypes()); |
| for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { |
| QualType T = NTTP->getExpansionType(I); |
| ID.AddPointer(T.getCanonicalType().getAsOpaquePtr()); |
| } |
| } else |
| ID.AddBoolean(false); |
| continue; |
| } |
| |
| auto *TTP = cast<TemplateTemplateParmDecl>(*P); |
| ID.AddInteger(2); |
| Profile(ID, TTP); |
| } |
| } |
| |
| TemplateTemplateParmDecl * |
| ASTContext::getCanonicalTemplateTemplateParmDecl( |
| TemplateTemplateParmDecl *TTP) const { |
| // Check if we already have a canonical template template parameter. |
| llvm::FoldingSetNodeID ID; |
| CanonicalTemplateTemplateParm::Profile(ID, TTP); |
| void *InsertPos = nullptr; |
| CanonicalTemplateTemplateParm *Canonical |
| = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); |
| if (Canonical) |
| return Canonical->getParam(); |
| |
| // Build a canonical template parameter list. |
| TemplateParameterList *Params = TTP->getTemplateParameters(); |
| SmallVector<NamedDecl *, 4> CanonParams; |
| CanonParams.reserve(Params->size()); |
| for (TemplateParameterList::const_iterator P = Params->begin(), |
| PEnd = Params->end(); |
| P != PEnd; ++P) { |
| if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) |
| CanonParams.push_back( |
| TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), |
| SourceLocation(), |
| SourceLocation(), |
| TTP->getDepth(), |
| TTP->getIndex(), nullptr, false, |
| TTP->isParameterPack())); |
| else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { |
| QualType T = getCanonicalType(NTTP->getType()); |
| TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); |
| NonTypeTemplateParmDecl *Param; |
| if (NTTP->isExpandedParameterPack()) { |
| SmallVector<QualType, 2> ExpandedTypes; |
| SmallVector<TypeSourceInfo *, 2> ExpandedTInfos; |
| for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { |
| ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I))); |
| ExpandedTInfos.push_back( |
| getTrivialTypeSourceInfo(ExpandedTypes.back())); |
| } |
| |
| Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), |
| SourceLocation(), |
| SourceLocation(), |
| NTTP->getDepth(), |
| NTTP->getPosition(), nullptr, |
| T, |
| TInfo, |
| ExpandedTypes, |
| ExpandedTInfos); |
| } else { |
| Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), |
| SourceLocation(), |
| SourceLocation(), |
| NTTP->getDepth(), |
| NTTP->getPosition(), nullptr, |
| T, |
| NTTP->isParameterPack(), |
| TInfo); |
| } |
| CanonParams.push_back(Param); |
| |
| } else |
| CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( |
| cast<TemplateTemplateParmDecl>(*P))); |
| } |
| |
| assert(!TTP->getTemplateParameters()->getRequiresClause() && |
| "Unexpected requires-clause on template template-parameter"); |
| Expr *const CanonRequiresClause = nullptr; |
| |
| TemplateTemplateParmDecl *CanonTTP |
| = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), |
| SourceLocation(), TTP->getDepth(), |
| TTP->getPosition(), |
| TTP->isParameterPack(), |
| nullptr, |
| TemplateParameterList::Create(*this, SourceLocation(), |
| SourceLocation(), |
| CanonParams, |
| SourceLocation(), |
| CanonRequiresClause)); |
| |
| // Get the new insert position for the node we care about. |
| Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); |
| assert(!Canonical && "Shouldn't be in the map!"); |
| (void)Canonical; |
| |
| // Create the canonical template template parameter entry. |
| Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); |
| CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); |
| return CanonTTP; |
| } |
| |
| CXXABI *ASTContext::createCXXABI(const TargetInfo &T) { |
| if (!LangOpts.CPlusPlus) return nullptr; |
| |
| switch (T.getCXXABI().getKind()) { |
| case TargetCXXABI::GenericARM: // Same as Itanium at this level |
| case TargetCXXABI::iOS: |
| case TargetCXXABI::iOS64: |
| case TargetCXXABI::WatchOS: |
| case TargetCXXABI::GenericAArch64: |
| case TargetCXXABI::GenericMIPS: |
| case TargetCXXABI::GenericItanium: |
| case TargetCXXABI::WebAssembly: |
| return CreateItaniumCXXABI(*this); |
| case TargetCXXABI::Microsoft: |
| return CreateMicrosoftCXXABI(*this); |
| } |
| llvm_unreachable("Invalid CXXABI type!"); |
| } |
| |
| interp::Context &ASTContext::getInterpContext() { |
| if (!InterpContext) { |
| InterpContext.reset(new interp::Context(*this)); |
| } |
| return *InterpContext.get(); |
| } |
| |
| static const LangASMap *getAddressSpaceMap(const TargetInfo &T, |
| const LangOptions &LOpts) { |
| if (LOpts.FakeAddressSpaceMap) { |
| // The fake address space map must have a distinct entry for each |
| // language-specific address space. |
| static const unsigned FakeAddrSpaceMap[] = { |
| 0, // Default |
| 1, // opencl_global |
| 3, // opencl_local |
| 2, // opencl_constant |
| 0, // opencl_private |
| 4, // opencl_generic |
| 5, // cuda_device |
| 6, // cuda_constant |
| 7 // cuda_shared |
| }; |
| return &FakeAddrSpaceMap; |
| } else { |
| return &T.getAddressSpaceMap(); |
| } |
| } |
| |
| static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI, |
| const LangOptions &LangOpts) { |
| switch (LangOpts.getAddressSpaceMapMangling()) { |
| case LangOptions::ASMM_Target: |
| return TI.useAddressSpaceMapMangling(); |
| case LangOptions::ASMM_On: |
| return true; |
| case LangOptions::ASMM_Off: |
| return false; |
| } |
| llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything."); |
| } |
| |
| ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM, |
| IdentifierTable &idents, SelectorTable &sels, |
| Builtin::Context &builtins) |
| : ConstantArrayTypes(this_()), FunctionProtoTypes(this_()), |
| TemplateSpecializationTypes(this_()), |
| DependentTemplateSpecializationTypes(this_()), |
| SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts), |
| SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)), |
| XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles, |
| LangOpts.XRayNeverInstrumentFiles, |
| LangOpts.XRayAttrListFiles, SM)), |
| PrintingPolicy(LOpts), Idents(idents), Selectors(sels), |
| BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM), |
| CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), |
| CompCategories(this_()), LastSDM(nullptr, 0) { |
| TUDecl = TranslationUnitDecl::Create(*this); |
| TraversalScope = {TUDecl}; |
| } |
| |
| ASTContext::~ASTContext() { |
| // Release the DenseMaps associated with DeclContext objects. |
| // FIXME: Is this the ideal solution? |
| ReleaseDeclContextMaps(); |
| |
| // Call all of the deallocation functions on all of their targets. |
| for (auto &Pair : Deallocations) |
| (Pair.first)(Pair.second); |
| |
| // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed |
| // because they can contain DenseMaps. |
| for (llvm::DenseMap<const ObjCContainerDecl*, |
| const ASTRecordLayout*>::iterator |
| I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) |
| // Increment in loop to prevent using deallocated memory. |
| if (auto *R = const_cast<ASTRecordLayout *>((I++)->second)) |
| R->Destroy(*this); |
| |
| for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator |
| I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { |
| // Increment in loop to prevent using deallocated memory. |
| if (auto *R = const_cast<ASTRecordLayout *>((I++)->second)) |
| R->Destroy(*this); |
| } |
| |
| for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), |
| AEnd = DeclAttrs.end(); |
| A != AEnd; ++A) |
| A->second->~AttrVec(); |
| |
| for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair : |
| MaterializedTemporaryValues) |
| MTVPair.second->~APValue(); |
| |
| for (const auto &Value : ModuleInitializers) |
| Value.second->~PerModuleInitializers(); |
| |
| for (APValue *Value : APValueCleanups) |
| Value->~APValue(); |
| } |
| |
| class ASTContext::ParentMap { |
| /// Contains parents of a node. |
| using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>; |
| |
| /// 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. |
| 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. |
| using ParentMapOtherNodes = llvm::DenseMap< |
| ast_type_traits::DynTypedNode, |
| llvm::PointerUnion4<const Decl *, const Stmt *, |
| ast_type_traits::DynTypedNode *, ParentVector *>>; |
| |
| ParentMapPointers PointerParents; |
| ParentMapOtherNodes OtherParents; |
| class ASTVisitor; |
| |
| static ast_type_traits::DynTypedNode |
| getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) { |
| if (const auto *D = U.dyn_cast<const Decl *>()) |
| return ast_type_traits::DynTypedNode::create(*D); |
| if (const auto *S = U.dyn_cast<const Stmt *>()) |
| return ast_type_traits::DynTypedNode::create(*S); |
| return *U.get<ast_type_traits::DynTypedNode *>(); |
| } |
| |
| template <typename NodeTy, typename MapTy> |
| static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node, |
| const MapTy &Map) { |
| auto I = Map.find(Node); |
| if (I == Map.end()) { |
| return llvm::ArrayRef<ast_type_traits::DynTypedNode>(); |
| } |
| if (const auto *V = I->second.template dyn_cast<ParentVector *>()) { |
| return llvm::makeArrayRef(*V); |
| } |
| return getSingleDynTypedNodeFromParentMap(I->second); |
| } |
| |
| public: |
| ParentMap(ASTContext &Ctx); |
| ~ParentMap() { |
| for (const auto &Entry : PointerParents) { |
| if (Entry.second.is<ast_type_traits::DynTypedNode *>()) { |
| delete Entry.second.get<ast_type_traits::DynTypedNode *>(); |
| } else if (Entry.second.is<ParentVector *>()) { |
| delete Entry.second.get<ParentVector *>(); |
| } |
| } |
| for (const auto &Entry : OtherParents) { |
| if (Entry.second.is<ast_type_traits::DynTypedNode *>()) { |
| delete Entry.second.get<ast_type_traits::DynTypedNode *>(); |
| } else if (Entry.second.is<ParentVector *>()) { |
| delete Entry.second.get<ParentVector *>(); |
| } |
| } |
| } |
| |
| DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node) { |
| if (Node.getNodeKind().hasPointerIdentity()) |
| return getDynNodeFromMap(Node.getMemoizationData(), PointerParents); |
| return getDynNodeFromMap(Node, OtherParents); |
| } |
| }; |
| |
| void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) { |
| TraversalScope = TopLevelDecls; |
| Parents.reset(); |
| } |
| |
| void ASTContext::AddDeallocation(void (*Callback)(void *), void *Data) const { |
| Deallocations.push_back({Callback, Data}); |
| } |
| |
| void |
| ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) { |
| ExternalSource = std::move(Source); |
| } |
| |
| void ASTContext::PrintStats() const { |
| llvm::errs() << "\n*** AST Context Stats:\n"; |
| llvm::errs() << " " << Types.size() << " types total.\n"; |
| |
| unsigned counts[] = { |
| #define TYPE(Name, Parent) 0, |
| #define ABSTRACT_TYPE(Name, Parent) |
| #include "clang/AST/TypeNodes.inc" |
| 0 // Extra |
| }; |
| |
| for (unsigned i = 0, e = Types.size(); i != e; ++i) { |
| Type *T = Types[i]; |
| counts[(unsigned)T->getTypeClass()]++; |
| } |
| |
| unsigned Idx = 0; |
| unsigned TotalBytes = 0; |
| #define TYPE(Name, Parent) \ |
| if (counts[Idx]) \ |
| llvm::errs() << " " << counts[Idx] << " " << #Name \ |
| << " types, " << sizeof(Name##Type) << " each " \ |
| << "(" << counts[Idx] * sizeof(Name##Type) \ |
| << " bytes)\n"; \ |
| TotalBytes += counts[Idx] * sizeof(Name##Type); \ |
| ++Idx; |
| #define ABSTRACT_TYPE(Name, Parent) |
| #include "clang/AST/TypeNodes.inc" |
| |
| llvm::errs() << "Total bytes = " << TotalBytes << "\n"; |
| |
| // Implicit special member functions. |
| llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" |
| << NumImplicitDefaultConstructors |
| << " implicit default constructors created\n"; |
| llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" |
| << NumImplicitCopyConstructors |
| << " implicit copy constructors created\n"; |
| if (getLangOpts().CPlusPlus) |
| llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" |
| << NumImplicitMoveConstructors |
| << " implicit move constructors created\n"; |
| llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" |
| << NumImplicitCopyAssignmentOperators |
| << " implicit copy assignment operators created\n"; |
| if (getLangOpts().CPlusPlus) |
| llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" |
| << NumImplicitMoveAssignmentOperators |
| << " implicit move assignment operators created\n"; |
| llvm::errs() << NumImplicitDestructorsDeclared << "/" |
| << NumImplicitDestructors |
| << " implicit destructors created\n"; |
| |
| if (ExternalSource) { |
| llvm::errs() << "\n"; |
| ExternalSource->PrintStats(); |
| } |
| |
| BumpAlloc.PrintStats(); |
| } |
| |
| void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M, |
| bool NotifyListeners) { |
| if (NotifyListeners) |
| if (auto *Listener = getASTMutationListener()) |
| Listener->RedefinedHiddenDefinition(ND, M); |
| |
| MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M); |
| } |
| |
| void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) { |
| auto It = MergedDefModules.find(cast<NamedDecl>(ND->getCanonicalDecl())); |
| if (It == MergedDefModules.end()) |
| return; |
| |
| auto &Merged = It->second; |
| llvm::DenseSet<Module*> Found; |
| for (Module *&M : Merged) |
| if (!Found.insert(M).second) |
| M = nullptr; |
| Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end()); |
| } |
| |
| void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) { |
| if (LazyInitializers.empty()) |
| return; |
| |
| auto *Source = Ctx.getExternalSource(); |
| assert(Source && "lazy initializers but no external source"); |
| |
| auto LazyInits = std::move(LazyInitializers); |
| LazyInitializers.clear(); |
| |
| for (auto ID : LazyInits) |
| Initializers.push_back(Source->GetExternalDecl(ID)); |
| |
| assert(LazyInitializers.empty() && |
| "GetExternalDecl for lazy module initializer added more inits"); |
| } |
| |
| void ASTContext::addModuleInitializer(Module *M, Decl *D) { |
| // One special case: if we add a module initializer that imports another |
| // module, and that module's only initializer is an ImportDecl, simplify. |
| if (const auto *ID = dyn_cast<ImportDecl>(D)) { |
| auto It = ModuleInitializers.find(ID->getImportedModule()); |
| |
| // Maybe the ImportDecl does nothing at all. (Common case.) |
| if (It == ModuleInitializers.end()) |
| return; |
| |
| // Maybe the ImportDecl only imports another ImportDecl. |
| auto &Imported = *It->second; |
| if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) { |
| Imported.resolve(*this); |
| auto *OnlyDecl = Imported.Initializers.front(); |
| if (isa<ImportDecl>(OnlyDecl)) |
| D = OnlyDecl; |
| } |
| } |
| |
| auto *&Inits = ModuleInitializers[M]; |
| if (!Inits) |
| Inits = new (*this) PerModuleInitializers; |
| Inits->Initializers.push_back(D); |
| } |
| |
| void ASTContext::addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs) { |
| auto *&Inits = ModuleInitializers[M]; |
| if (!Inits) |
| Inits = new (*this) PerModuleInitializers; |
| Inits->LazyInitializers.insert(Inits->LazyInitializers.end(), |
| IDs.begin(), IDs.end()); |
| } |
| |
| ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) { |
| auto It = ModuleInitializers.find(M); |
| if (It == ModuleInitializers.end()) |
| return None; |
| |
| auto *Inits = It->second; |
| Inits->resolve(*this); |
| return Inits->Initializers; |
| } |
| |
| ExternCContextDecl *ASTContext::getExternCContextDecl() const { |
| if (!ExternCContext) |
| ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl()); |
| |
| return ExternCContext; |
| } |
| |
| BuiltinTemplateDecl * |
| ASTContext::buildBuiltinTemplateDecl(BuiltinTemplateKind BTK, |
| const IdentifierInfo *II) const { |
| auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK); |
| BuiltinTemplate->setImplicit(); |
| TUDecl->addDecl(BuiltinTemplate); |
| |
| return BuiltinTemplate; |
| } |
| |
| BuiltinTemplateDecl * |
| ASTContext::getMakeIntegerSeqDecl() const { |
| if (!MakeIntegerSeqDecl) |
| MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq, |
| getMakeIntegerSeqName()); |
| return MakeIntegerSeqDecl; |
| } |
| |
| BuiltinTemplateDecl * |
| ASTContext::getTypePackElementDecl() const { |
| if (!TypePackElementDecl) |
| TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element, |
| getTypePackElementName()); |
| return TypePackElementDecl; |
| } |
| |
| RecordDecl *ASTContext::buildImplicitRecord(StringRef Name, |
| RecordDecl::TagKind TK) const { |
| SourceLocation Loc; |
| RecordDecl *NewDecl; |
| if (getLangOpts().CPlusPlus) |
| NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, |
| Loc, &Idents.get(Name)); |
| else |
| NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc, |
| &Idents.get(Name)); |
| NewDecl->setImplicit(); |
| NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit( |
| const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default)); |
| return NewDecl; |
| } |
| |
| TypedefDecl *ASTContext::buildImplicitTypedef(QualType T, |
| StringRef Name) const { |
| TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); |
| TypedefDecl *NewDecl = TypedefDecl::Create( |
| const_cast<ASTContext &>(*this), getTranslationUnitDecl(), |
| SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo); |
| NewDecl->setImplicit(); |
| return NewDecl; |
| } |
| |
| TypedefDecl *ASTContext::getInt128Decl() const { |
| if (!Int128Decl) |
| Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t"); |
| return Int128Decl; |
| } |
| |
| TypedefDecl *ASTContext::getUInt128Decl() const { |
| if (!UInt128Decl) |
| UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t"); |
| return UInt128Decl; |
| } |
| |
| void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { |
| auto *Ty = new (*this, TypeAlignment) BuiltinType(K); |
| R = CanQualType::CreateUnsafe(QualType(Ty, 0)); |
| Types.push_back(Ty); |
| } |
| |
| void ASTContext::InitBuiltinTypes(const TargetInfo &Target, |
| const TargetInfo *AuxTarget) { |
| assert((!this->Target || this->Target == &Target) && |
| "Incorrect target reinitialization"); |
| assert(VoidTy.isNull() && "Context reinitialized?"); |
| |
| this->Target = &Target; |
| this->AuxTarget = AuxTarget; |
| |
| ABI.reset(createCXXABI(Target)); |
| AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); |
| AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts); |
| |
| // C99 6.2.5p19. |
| InitBuiltinType(VoidTy, BuiltinType::Void); |
| |
| // C99 6.2.5p2. |
| InitBuiltinType(BoolTy, BuiltinType::Bool); |
| // C99 6.2.5p3. |
| if (LangOpts.CharIsSigned) |
| InitBuiltinType(CharTy, BuiltinType::Char_S); |
| else |
| InitBuiltinType(CharTy, BuiltinType::Char_U); |
| // C99 6.2.5p4. |
| InitBuiltinType(SignedCharTy, BuiltinType::SChar); |
| InitBuiltinType(ShortTy, BuiltinType::Short); |
| InitBuiltinType(IntTy, BuiltinType::Int); |
| InitBuiltinType(LongTy, BuiltinType::Long); |
| InitBuiltinType(LongLongTy, BuiltinType::LongLong); |
| |
| // C99 6.2.5p6. |
| InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); |
| InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); |
| InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); |
| InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); |
| InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); |
| |
| // C99 6.2.5p10. |
| InitBuiltinType(FloatTy, BuiltinType::Float); |
| InitBuiltinType(DoubleTy, BuiltinType::Double); |
| InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); |
| |
| // GNU extension, __float128 for IEEE quadruple precision |
| InitBuiltinType(Float128Ty, BuiltinType::Float128); |
| |
| // C11 extension ISO/IEC TS 18661-3 |
| InitBuiltinType(Float16Ty, BuiltinType::Float16); |
| |
| // ISO/IEC JTC1 SC22 WG14 N1169 Extension |
| InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum); |
| InitBuiltinType(AccumTy, BuiltinType::Accum); |
| InitBuiltinType(LongAccumTy, BuiltinType::LongAccum); |
| InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum); |
| InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum); |
| InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum); |
| InitBuiltinType(ShortFractTy, BuiltinType::ShortFract); |
| InitBuiltinType(FractTy, BuiltinType::Fract); |
| InitBuiltinType(LongFractTy, BuiltinType::LongFract); |
| InitBuiltinType(UnsignedShortFractTy, BuiltinType::UShortFract); |
| InitBuiltinType(UnsignedFractTy, BuiltinType::UFract); |
| InitBuiltinType(UnsignedLongFractTy, BuiltinType::ULongFract); |
| InitBuiltinType(SatShortAccumTy, BuiltinType::SatShortAccum); |
| InitBuiltinType(SatAccumTy, BuiltinType::SatAccum); |
| InitBuiltinType(SatLongAccumTy, BuiltinType::SatLongAccum); |
| InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum); |
| InitBuiltinType(SatUnsignedAccumTy, BuiltinType::SatUAccum); |
| InitBuiltinType(SatUnsignedLongAccumTy, BuiltinType::SatULongAccum); |
| InitBuiltinType(SatShortFractTy, BuiltinType::SatShortFract); |
| InitBuiltinType(SatFractTy, BuiltinType::SatFract); |
| InitBuiltinType(SatLongFractTy, BuiltinType::SatLongFract); |
| InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract); |
| InitBuiltinType(SatUnsignedFractTy, BuiltinType::SatUFract); |
| InitBuiltinType(SatUnsignedLongFractTy, BuiltinType::SatULongFract); |
| |
| // GNU extension, 128-bit integers. |
| InitBuiltinType(Int128Ty, BuiltinType::Int128); |
| InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); |
| |
| // C++ 3.9.1p5 |
| if (TargetInfo::isTypeSigned(Target.getWCharType())) |
| InitBuiltinType(WCharTy, BuiltinType::WChar_S); |
| else // -fshort-wchar makes wchar_t be unsigned. |
| InitBuiltinType(WCharTy, BuiltinType::WChar_U); |
| if (LangOpts.CPlusPlus && LangOpts.WChar) |
| WideCharTy = WCharTy; |
| else { |
| // C99 (or C++ using -fno-wchar). |
| WideCharTy = getFromTargetType(Target.getWCharType()); |
| } |
| |
| WIntTy = getFromTargetType(Target.getWIntType()); |
| |
| // C++20 (proposed) |
| InitBuiltinType(Char8Ty, BuiltinType::Char8); |
| |
| if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ |
| InitBuiltinType(Char16Ty, BuiltinType::Char16); |
| else // C99 |
| Char16Ty = getFromTargetType(Target.getChar16Type()); |
| |
| if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ |
| InitBuiltinType(Char32Ty, BuiltinType::Char32); |
| else // C99 |
| Char32Ty = getFromTargetType(Target.getChar32Type()); |
| |
| // Placeholder type for type-dependent expressions whose type is |
| // completely unknown. No code should ever check a type against |
| // DependentTy and users should never see it; however, it is here to |
| // help diagnose failures to properly check for type-dependent |
| // expressions. |
| InitBuiltinType(DependentTy, BuiltinType::Dependent); |
| |
| // Placeholder type for functions. |
| InitBuiltinType(OverloadTy, BuiltinType::Overload); |
| |
| // Placeholder type for bound members. |
| InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); |
| |
| // Placeholder type for pseudo-objects. |
| InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); |
| |
| // "any" type; useful for debugger-like clients. |
| InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); |
| |
| // Placeholder type for unbridged ARC casts. |
| InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); |
| |
| // Placeholder type for builtin functions. |
| InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn); |
| |
| // Placeholder type for OMP array sections. |
| if (LangOpts.OpenMP) |
| InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection); |
| |
| // C99 6.2.5p11. |
| FloatComplexTy = getComplexType(FloatTy); |
| DoubleComplexTy = getComplexType(DoubleTy); |
| LongDoubleComplexTy = getComplexType(LongDoubleTy); |
| Float128ComplexTy = getComplexType(Float128Ty); |
| |
| // Builtin types for 'id', 'Class', and 'SEL'. |
| InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); |
| InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); |
| InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); |
| |
| if (LangOpts.OpenCL) { |
| #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ |
| InitBuiltinType(SingletonId, BuiltinType::Id); |
| #include "clang/Basic/OpenCLImageTypes.def" |
| |
| InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler); |
| InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent); |
| InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent); |
| InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue); |
| InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID); |
| |
| #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ |
| InitBuiltinType(Id##Ty, BuiltinType::Id); |
| #include "clang/Basic/OpenCLExtensionTypes.def" |
| } |
| |
| if (Target.hasAArch64SVETypes()) { |
| #define SVE_TYPE(Name, Id, SingletonId) \ |
| InitBuiltinType(SingletonId, BuiltinType::Id); |
| #include "clang/Basic/AArch64SVEACLETypes.def" |
| } |
| |
| // Builtin type for __objc_yes and __objc_no |
| ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? |
| SignedCharTy : BoolTy); |
| |
| ObjCConstantStringType = QualType(); |
| |
| ObjCSuperType = QualType(); |
| |
| // void * type |
| if (LangOpts.OpenCLVersion >= 200) { |
| auto Q = VoidTy.getQualifiers(); |
| Q.setAddressSpace(LangAS::opencl_generic); |
| VoidPtrTy = getPointerType(getCanonicalType( |
| getQualifiedType(VoidTy.getUnqualifiedType(), Q))); |
| } else { |
| VoidPtrTy = getPointerType(VoidTy); |
| } |
| |
| // nullptr type (C++0x 2.14.7) |
| InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); |
| |
| // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 |
| InitBuiltinType(HalfTy, BuiltinType::Half); |
| |
| // Builtin type used to help define __builtin_va_list. |
| VaListTagDecl = nullptr; |
| } |
| |
| DiagnosticsEngine &ASTContext::getDiagnostics() const { |
| return SourceMgr.getDiagnostics(); |
| } |
| |
| AttrVec& ASTContext::getDeclAttrs(const Decl *D) { |
| AttrVec *&Result = DeclAttrs[D]; |
| if (!Result) { |
| void *Mem = Allocate(sizeof(AttrVec)); |
| Result = new (Mem) AttrVec; |
| } |
| |
| return *Result; |
| } |
| |
| /// Erase the attributes corresponding to the given declaration. |
| void ASTContext::eraseDeclAttrs(const Decl *D) { |
| llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); |
| if (Pos != DeclAttrs.end()) { |
| Pos->second->~AttrVec(); |
| DeclAttrs.erase(Pos); |
| } |
| } |
| |
| // FIXME: Remove ? |
| MemberSpecializationInfo * |
| ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { |
| assert(Var->isStaticDataMember() && "Not a static data member"); |
| return getTemplateOrSpecializationInfo(Var) |
| .dyn_cast<MemberSpecializationInfo *>(); |
| } |
| |
| ASTContext::TemplateOrSpecializationInfo |
| ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) { |
| llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos = |
| TemplateOrInstantiation.find(Var); |
| if (Pos == TemplateOrInstantiation.end()) |
| return {}; |
| |
| return Pos->second; |
| } |
| |
| void |
| ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, |
| TemplateSpecializationKind TSK, |
| SourceLocation PointOfInstantiation) { |
| assert(Inst->isStaticDataMember() && "Not a static data member"); |
| assert(Tmpl->isStaticDataMember() && "Not a static data member"); |
| setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo( |
| Tmpl, TSK, PointOfInstantiation)); |
| } |
| |
| void |
| ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst, |
| TemplateOrSpecializationInfo TSI) { |
| assert(!TemplateOrInstantiation[Inst] && |
| "Already noted what the variable was instantiated from"); |
| TemplateOrInstantiation[Inst] = TSI; |
| } |
| |
| NamedDecl * |
| ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) { |
| auto Pos = InstantiatedFromUsingDecl.find(UUD); |
| if (Pos == InstantiatedFromUsingDecl.end()) |
| return nullptr; |
| |
| return Pos->second; |
| } |
| |
| void |
| ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern) { |
| assert((isa<UsingDecl>(Pattern) || |
| isa<UnresolvedUsingValueDecl>(Pattern) || |
| isa<UnresolvedUsingTypenameDecl>(Pattern)) && |
| "pattern decl is not a using decl"); |
| assert((isa<UsingDecl>(Inst) || |
| isa<UnresolvedUsingValueDecl>(Inst) || |
| isa<UnresolvedUsingTypenameDecl>(Inst)) && |
| "instantiation did not produce a using decl"); |
| assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); |
| InstantiatedFromUsingDecl[Inst] = Pattern; |
| } |
| |
| UsingShadowDecl * |
| ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { |
| llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos |
| = InstantiatedFromUsingShadowDecl.find(Inst); |
| if (Pos == InstantiatedFromUsingShadowDecl.end()) |
| return nullptr; |
| |
| return Pos->second; |
| } |
| |
| void |
| ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, |
| UsingShadowDecl *Pattern) { |
| assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); |
| InstantiatedFromUsingShadowDecl[Inst] = Pattern; |
| } |
| |
| FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { |
| llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos |
| = InstantiatedFromUnnamedFieldDecl.find(Field); |
| if (Pos == InstantiatedFromUnnamedFieldDecl.end()) |
| return nullptr; |
| |
| return Pos->second; |
| } |
| |
| void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, |
| FieldDecl *Tmpl) { |
| assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); |
| assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); |
| assert(!InstantiatedFromUnnamedFieldDecl[Inst] && |
| "Already noted what unnamed field was instantiated from"); |
| |
| InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; |
| } |
| |
| ASTContext::overridden_cxx_method_iterator |
| ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { |
| return overridden_methods(Method).begin(); |
| } |
| |
| ASTContext::overridden_cxx_method_iterator |
| ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { |
| return overridden_methods(Method).end(); |
| } |
| |
| unsigned |
| ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { |
| auto Range = overridden_methods(Method); |
| return Range.end() - Range.begin(); |
| } |
| |
| ASTContext::overridden_method_range |
| ASTContext::overridden_methods(const CXXMethodDecl *Method) const { |
| llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos = |
| OverriddenMethods.find(Method->getCanonicalDecl()); |
| if (Pos == OverriddenMethods.end()) |
| return overridden_method_range(nullptr, nullptr); |
| return overridden_method_range(Pos->second.begin(), Pos->second.end()); |
| } |
| |
| void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, |
| const CXXMethodDecl *Overridden) { |
| assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl()); |
| OverriddenMethods[Method].push_back(Overridden); |
| } |
| |
| void ASTContext::getOverriddenMethods( |
| const NamedDecl *D, |
| SmallVectorImpl<const NamedDecl *> &Overridden) const { |
| assert(D); |
| |
| if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) { |
| Overridden.append(overridden_methods_begin(CXXMethod), |
| overridden_methods_end(CXXMethod)); |
| return; |
| } |
| |
| const auto *Method = dyn_cast<ObjCMethodDecl>(D); |
| if (!Method) |
| return; |
| |
| SmallVector<const ObjCMethodDecl *, 8> OverDecls; |
| Method->getOverriddenMethods(OverDecls); |
| Overridden.append(OverDecls.begin(), OverDecls.end()); |
| } |
| |
| void ASTContext::addedLocalImportDecl(ImportDecl *Import) { |
| assert(!Import->NextLocalImport && "Import declaration already in the chain"); |
| assert(!Import->isFromASTFile() && "Non-local import declaration"); |
| if (!FirstLocalImport) { |
| FirstLocalImport = Import; |
| LastLocalImport = Import; |
| return; |
| } |
| |
| LastLocalImport->NextLocalImport = Import; |
| LastLocalImport = Import; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Type Sizing and Analysis |
| //===----------------------------------------------------------------------===// |
| |
| /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified |
| /// scalar floating point type. |
| const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { |
| switch (T->castAs<BuiltinType>()->getKind()) { |
| default: |
| llvm_unreachable("Not a floating point type!"); |
| case BuiltinType::Float16: |
| case BuiltinType::Half: |
| return Target->getHalfFormat(); |
| case BuiltinType::Float: return Target->getFloatFormat(); |
| case BuiltinType::Double: return Target->getDoubleFormat(); |
| case BuiltinType::LongDouble: |
| if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice) |
| return AuxTarget->getLongDoubleFormat(); |
| return Target->getLongDoubleFormat(); |
| case BuiltinType::Float128: |
| if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice) |
| return AuxTarget->getFloat128Format(); |
| return Target->getFloat128Format(); |
| } |
| } |
| |
| CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const { |
| unsigned Align = Target->getCharWidth(); |
| |
| bool UseAlignAttrOnly = false; |
| if (unsigned AlignFromAttr = D->getMaxAlignment()) { |
| Align = AlignFromAttr; |
| |
| // __attribute__((aligned)) can increase or decrease alignment |
| // *except* on a struct or struct member, where it only increases |
| // alignment unless 'packed' is also specified. |
| // |
| // It is an error for alignas to decrease alignment, so we can |
| // ignore that possibility; Sema should diagnose it. |
| if (isa<FieldDecl>(D)) { |
| UseAlignAttrOnly = D->hasAttr<PackedAttr>() || |
| cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); |
| } else { |
| UseAlignAttrOnly = true; |
| } |
| } |
| else if (isa<FieldDecl>(D)) |
| UseAlignAttrOnly = |
| D->hasAttr<PackedAttr>() || |
| cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); |
| |
| // If we're using the align attribute only, just ignore everything |
| // else about the declaration and its type. |
| if (UseAlignAttrOnly) { |
| // do nothing |
| } else if (const auto *VD = dyn_cast<ValueDecl>(D)) { |
| QualType T = VD->getType(); |
| if (const auto *RT = T->getAs<ReferenceType>()) { |
| if (ForAlignof) |
| T = RT->getPointeeType(); |
| else |
| T = getPointerType(RT->getPointeeType()); |
| } |
| QualType BaseT = getBaseElementType(T); |
| if (T->isFunctionType()) |
| Align = getTypeInfoImpl(T.getTypePtr()).Align; |
| else if (!BaseT->isIncompleteType()) { |
| // Adjust alignments of declarations with array type by the |
| // large-array alignment on the target. |
| if (const ArrayType *arrayType = getAsArrayType(T)) { |
| unsigned MinWidth = Target->getLargeArrayMinWidth(); |
| if (!ForAlignof && MinWidth) { |
| if (isa<VariableArrayType>(arrayType)) |
| Align = std::max(Align, Target->getLargeArrayAlign()); |
| else if (isa<ConstantArrayType>(arrayType) && |
| MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) |
| Align = std::max(Align, Target->getLargeArrayAlign()); |
| } |
| } |
| Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); |
| if (BaseT.getQualifiers().hasUnaligned()) |
| Align = Target->getCharWidth(); |
| if (const auto *VD = dyn_cast<VarDecl>(D)) { |
| if (VD->hasGlobalStorage() && !ForAlignof) { |
| uint64_t TypeSize = getTypeSize(T.getTypePtr()); |
| Align = std::max(Align, getTargetInfo().getMinGlobalAlign(TypeSize)); |
| } |
| } |
| } |
| |
| // Fields can be subject to extra alignment constraints, like if |
| // the field is packed, the struct is packed, or the struct has a |
| // a max-field-alignment constraint (#pragma pack). So calculate |
| // the actual alignment of the field within the struct, and then |
| // (as we're expected to) constrain that by the alignment of the type. |
| if (const auto *Field = dyn_cast<FieldDecl>(VD)) { |
| const RecordDecl *Parent = Field->getParent(); |
| // We can only produce a sensible answer if the record is valid. |
| if (!Parent->isInvalidDecl()) { |
| const ASTRecordLayout &Layout = getASTRecordLayout(Parent); |
| |
| // Start with the record's overall alignment. |
| unsigned FieldAlign = toBits(Layout.getAlignment()); |
| |
| // Use the GCD of that and the offset within the record. |
| uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex()); |
| if (Offset > 0) { |
| // Alignment is always a power of 2, so the GCD will be a power of 2, |
| // which means we get to do this crazy thing instead of Euclid's. |
| uint64_t LowBitOfOffset = Offset & (~Offset + 1); |
| if (LowBitOfOffset < FieldAlign) |
| FieldAlign = static_cast<unsigned>(LowBitOfOffset); |
| } |
| |
| Align = std::min(Align, FieldAlign); |
| } |
| } |
| } |
| |
| return toCharUnitsFromBits(Align); |
| } |
| |
| // getTypeInfoDataSizeInChars - Return the size of a type, in |
| // chars. If the type is a record, its data size is returned. This is |
| // the size of the memcpy that's performed when assigning this type |
| // using a trivial copy/move assignment operator. |
| std::pair<CharUnits, CharUnits> |
| ASTContext::getTypeInfoDataSizeInChars(QualType T) const { |
| std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T); |
| |
| // In C++, objects can sometimes be allocated into the tail padding |
| // of a base-class subobject. We decide whether that's possible |
| // during class layout, so here we can just trust the layout results. |
| if (getLangOpts().CPlusPlus) { |
| if (const auto *RT = T->getAs<RecordType>()) { |
| const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl()); |
| sizeAndAlign.first = layout.getDataSize(); |
| } |
| } |
| |
| return sizeAndAlign; |
| } |
| |
| /// getConstantArrayInfoInChars - Performing the computation in CharUnits |
| /// instead of in bits prevents overflowing the uint64_t for some large arrays. |
| std::pair<CharUnits, CharUnits> |
| static getConstantArrayInfoInChars(const ASTContext &Context, |
| const ConstantArrayType *CAT) { |
| std::pair<CharUnits, CharUnits> EltInfo = |
| Context.getTypeInfoInChars(CAT->getElementType()); |
| uint64_t Size = CAT->getSize().getZExtValue(); |
| assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= |
| (uint64_t)(-1)/Size) && |
| "Overflow in array type char size evaluation"); |
| uint64_t Width = EltInfo.first.getQuantity() * Size; |
| unsigned Align = EltInfo.second.getQuantity(); |
| if (!Context.getTargetInfo().getCXXABI().isMicrosoft() || |
| Context.getTargetInfo().getPointerWidth(0) == 64) |
| Width = llvm::alignTo(Width, Align); |
| return std::make_pair(CharUnits::fromQuantity(Width), |
| CharUnits::fromQuantity(Align)); |
| } |
| |
| std::pair<CharUnits, CharUnits> |
| ASTContext::getTypeInfoInChars(const Type *T) const { |
| if (const auto *CAT = dyn_cast<ConstantArrayType>(T)) |
| return getConstantArrayInfoInChars(*this, CAT); |
| TypeInfo Info = getTypeInfo(T); |
| return std::make_pair(toCharUnitsFromBits(Info.Width), |
| toCharUnitsFromBits(Info.Align)); |
| } |
| |
| std::pair<CharUnits, CharUnits> |
| ASTContext::getTypeInfoInChars(QualType T) const { |
| return getTypeInfoInChars(T.getTypePtr()); |
| } |
| |
| bool ASTContext::isAlignmentRequired(const Type *T) const { |
| return getTypeInfo(T).AlignIsRequired; |
| } |
| |
| bool ASTContext::isAlignmentRequired(QualType T) const { |
| return isAlignmentRequired(T.getTypePtr()); |
| } |
| |
| unsigned ASTContext::getTypeAlignIfKnown(QualType T) const { |
| // An alignment on a typedef overrides anything else. |
| if (const auto *TT = T->getAs<TypedefType>()) |
| if (unsigned Align = TT->getDecl()->getMaxAlignment()) |
| return Align; |
| |
| // If we have an (array of) complete type, we're done. |
| T = getBaseElementType(T); |
| if (!T->isIncompleteType()) |
| return getTypeAlign(T); |
| |
| // If we had an array type, its element type might be a typedef |
| // type with an alignment attribute. |
| if (const auto *TT = T->getAs<TypedefType>()) |
| if (unsigned Align = TT->getDecl()->getMaxAlignment()) |
| return Align; |
| |
| // Otherwise, see if the declaration of the type had an attribute. |
| if (const auto *TT = T->getAs<TagType>()) |
| return TT->getDecl()->getMaxAlignment(); |
| |
| return 0; |
| } |
| |
| TypeInfo ASTContext::getTypeInfo(const Type *T) const { |
| TypeInfoMap::iterator I = MemoizedTypeInfo.find(T); |
| if (I != MemoizedTypeInfo.end()) |
| return I->second; |
| |
| // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup. |
| TypeInfo TI = getTypeInfoImpl(T); |
| MemoizedTypeInfo[T] = TI; |
| return TI; |
| } |
| |
| /// getTypeInfoImpl - Return the size of the specified type, in bits. This |
| /// method does not work on incomplete types. |
| /// |
| /// FIXME: Pointers into different addr spaces could have different sizes and |
| /// alignment requirements: getPointerInfo should take an AddrSpace, this |
| /// should take a QualType, &c. |
| TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const { |
| uint64_t Width = 0; |
| unsigned Align = 8; |
| bool AlignIsRequired = false; |
| unsigned AS = 0; |
| switch (T->getTypeClass()) { |
| #define TYPE(Class, Base) |
| #define ABSTRACT_TYPE(Class, Base) |
| #define NON_CANONICAL_TYPE(Class, Base) |
| #define DEPENDENT_TYPE(Class, Base) case Type::Class: |
| #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \ |
| case Type::Class: \ |
| assert(!T->isDependentType() && "should not see dependent types here"); \ |
| return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr()); |
| #include "clang/AST/TypeNodes.inc" |
| llvm_unreachable("Should not see dependent types"); |
| |
| case Type::FunctionNoProto: |
| case Type::FunctionProto: |
| // GCC extension: alignof(function) = 32 bits |
| Width = 0; |
| Align = 32; |
| break; |
| |
| case Type::IncompleteArray: |
| case Type::VariableArray: |
| Width = 0; |
| Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); |
| break; |
| |
| case Type::ConstantArray: { |
| const auto *CAT = cast<ConstantArrayType>(T); |
| |
| TypeInfo EltInfo = getTypeInfo(CAT->getElementType()); |
| uint64_t Size = CAT->getSize().getZExtValue(); |
| assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && |
| "Overflow in array type bit size evaluation"); |
| Width = EltInfo.Width * Size; |
| Align = EltInfo.Align; |
| if (!getTargetInfo().getCXXABI().isMicrosoft() || |
| getTargetInfo().getPointerWidth(0) == 64) |
| Width = llvm::alignTo(Width, Align); |
| break; |
| } |
| case Type::ExtVector: |
| case Type::Vector: { |
| const auto *VT = cast<VectorType>(T); |
| TypeInfo EltInfo = getTypeInfo(VT->getElementType()); |
| Width = EltInfo.Width * VT->getNumElements(); |
| Align = Width; |
| // If the alignment is not a power of 2, round up to the next power of 2. |
| // This happens for non-power-of-2 length vectors. |
| if (Align & (Align-1)) { |
| Align = llvm::NextPowerOf2(Align); |
| Width = llvm::alignTo(Width, Align); |
| } |
| // Adjust the alignment based on the target max. |
| uint64_t TargetVectorAlign = Target->getMaxVectorAlign(); |
| if (TargetVectorAlign && TargetVectorAlign < Align) |
| Align = TargetVectorAlign; |
| break; |
| } |
| |
| case Type::Builtin: |
| switch (cast<BuiltinType>(T)->getKind()) { |
| default: llvm_unreachable("Unknown builtin type!"); |
| case BuiltinType::Void: |
| // GCC extension: alignof(void) = 8 bits. |
| Width = 0; |
| Align = 8; |
| break; |
| case BuiltinType::Bool: |
| Width = Target->getBoolWidth(); |
| Align = Target->getBoolAlign(); |
| break; |
| case BuiltinType::Char_S: |
| case BuiltinType::Char_U: |
| case BuiltinType::UChar: |
| case BuiltinType::SChar: |
| case BuiltinType::Char8: |
| Width = Target->getCharWidth(); |
| Align = Target->getCharAlign(); |
| break; |
| case BuiltinType::WChar_S: |
| case BuiltinType::WChar_U: |
| Width = Target->getWCharWidth(); |
| Align = Target->getWCharAlign(); |
| break; |
| case BuiltinType::Char16: |
| Width = Target->getChar16Width(); |
| Align = Target->getChar16Align(); |
| break; |
| case BuiltinType::Char32: |
| Width = Target->getChar32Width(); |
| Align = Target->getChar32Align(); |
| break; |
| case BuiltinType::UShort: |
| case BuiltinType::Short: |
| Width = Target->getShortWidth(); |
| Align = Target->getShortAlign(); |
| break; |
| case BuiltinType::UInt: |
| case BuiltinType::Int: |
| Width = Target->getIntWidth(); |
| Align = Target->getIntAlign(); |
| break; |
| case BuiltinType::ULong: |
| case BuiltinType::Long: |
| Width = Target->getLongWidth(); |
| Align = Target->getLongAlign(); |
| break; |
| case BuiltinType::ULongLong: |
| case BuiltinType::LongLong: |
| Width = Target->getLongLongWidth(); |
| Align = Target->getLongLongAlign(); |
| break; |
| case BuiltinType::Int128: |
| case BuiltinType::UInt128: |
| Width = 128; |
| Align = 128; // int128_t is 128-bit aligned on all targets. |
| break; |
| case BuiltinType::ShortAccum: |
| case BuiltinType::UShortAccum: |
| case BuiltinType::SatShortAccum: |
| case BuiltinType::SatUShortAccum: |
| Width = Target->getShortAccumWidth(); |
| Align = Target->getShortAccumAlign(); |
| break; |
| case BuiltinType::Accum: |
| case BuiltinType::UAccum: |
| case BuiltinType::SatAccum: |
| case BuiltinType::SatUAccum: |
| Width = Target->getAccumWidth(); |
| Align = Target->getAccumAlign(); |
| break; |
| case BuiltinType::LongAccum: |
| case BuiltinType::ULongAccum: |
| case BuiltinType::SatLongAccum: |
| case BuiltinType::SatULongAccum: |
| Width = Target->getLongAccumWidth(); |
| Align = Target->getLongAccumAlign(); |
| break; |
| case BuiltinType::ShortFract: |
| case BuiltinType::UShortFract: |
| case BuiltinType::SatShortFract: |
| case BuiltinType::SatUShortFract: |
| Width = Target->getShortFractWidth(); |
| Align = Target->getShortFractAlign(); |
| break; |
| case BuiltinType::Fract: |
| case BuiltinType::UFract: |
| case BuiltinType::SatFract: |
| case BuiltinType::SatUFract: |
| Width = Target->getFractWidth(); |
| Align = Target->getFractAlign(); |
| break; |
| case BuiltinType::LongFract: |
| case BuiltinType::ULongFract: |
| case BuiltinType::SatLongFract: |
| case BuiltinType::SatULongFract: |
| Width = Target->getLongFractWidth(); |
| Align = Target->getLongFractAlign(); |
| break; |
| case BuiltinType::Float16: |
| case BuiltinType::Half: |
| if (Target->hasFloat16Type() || !getLangOpts().OpenMP || |
| !getLangOpts().OpenMPIsDevice) { |
| Width = Target->getHalfWidth(); |
| Align = Target->getHalfAlign(); |
| } else { |
| assert(getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && |
| "Expected OpenMP device compilation."); |
| Width = AuxTarget->getHalfWidth(); |
| Align = AuxTarget->getHalfAlign(); |
| } |
| break; |
| case BuiltinType::Float: |
| Width = Target->getFloatWidth(); |
| Align = Target->getFloatAlign(); |
| break; |
| case BuiltinType::Double: |
| Width = Target->getDoubleWidth(); |
| Align = Target->getDoubleAlign(); |
| break; |
| case BuiltinType::LongDouble: |
| if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && |
| (Target->getLongDoubleWidth() != AuxTarget->getLongDoubleWidth() || |
| Target->getLongDoubleAlign() != AuxTarget->getLongDoubleAlign())) { |
| Width = AuxTarget->getLongDoubleWidth(); |
| Align = AuxTarget->getLongDoubleAlign(); |
| } else { |
| Width = Target->getLongDoubleWidth(); |
| Align = Target->getLongDoubleAlign(); |
| } |
| break; |
| case BuiltinType::Float128: |
| if (Target->hasFloat128Type() || !getLangOpts().OpenMP || |
| !getLangOpts().OpenMPIsDevice) { |
| Width = Target->getFloat128Width(); |
| Align = Target->getFloat128Align(); |
| } else { |
| assert(getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && |
| "Expected OpenMP device compilation."); |
| Width = AuxTarget->getFloat128Width(); |
| Align = AuxTarget->getFloat128Align(); |
| } |
| break; |
| case BuiltinType::NullPtr: |
| Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) |
| Align = Target->getPointerAlign(0); // == sizeof(void*) |
| break; |
| case BuiltinType::ObjCId: |
| case BuiltinType::ObjCClass: |
| case BuiltinType::ObjCSel: |
| Width = Target->getPointerWidth(0); |
| Align = Target->getPointerAlign(0); |
| break; |
| case BuiltinType::OCLSampler: |
| case BuiltinType::OCLEvent: |
| case BuiltinType::OCLClkEvent: |
| case BuiltinType::OCLQueue: |
| case BuiltinType::OCLReserveID: |
| #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ |
| case BuiltinType::Id: |
| #include "clang/Basic/OpenCLImageTypes.def" |
| #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ |
| case BuiltinType::Id: |
| #include "clang/Basic/OpenCLExtensionTypes.def" |
| AS = getTargetAddressSpace( |
| Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T))); |
| Width = Target->getPointerWidth(AS); |
| Align = Target->getPointerAlign(AS); |
| break; |
| // The SVE types are effectively target-specific. The length of an |
| // SVE_VECTOR_TYPE is only known at runtime, but it is always a multiple |
| // of 128 bits. There is one predicate bit for each vector byte, so the |
| // length of an SVE_PREDICATE_TYPE is always a multiple of 16 bits. |
| // |
| // Because the length is only known at runtime, we use a dummy value |
| // of 0 for the static length. The alignment values are those defined |
| // by the Procedure Call Standard for the Arm Architecture. |
| #define SVE_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, IsSigned, IsFP)\ |
| case BuiltinType::Id: \ |
| Width = 0; \ |
| Align = 128; \ |
| break; |
| #define SVE_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \ |
| case BuiltinType::Id: \ |
| Width = 0; \ |
| Align = 16; \ |
| break; |
| #include "clang/Basic/AArch64SVEACLETypes.def" |
| } |
| break; |
| case Type::ObjCObjectPointer: |
| Width = Target->getPointerWidth(0); |
| Align = Target->getPointerAlign(0); |
| break; |
| case Type::BlockPointer: |
| AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType()); |
| Width = Target->getPointerWidth(AS); |
| Align = Target->getPointerAlign(AS); |
| break; |
| case Type::LValueReference: |
| case Type::RValueReference: |
| // alignof and sizeof should never enter this code path here, so we go |
| // the pointer route. |
| AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType()); |
| Width = Target->getPointerWidth(AS); |
| Align = Target->getPointerAlign(AS); |
| break; |
| case Type::Pointer: |
| AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); |
| Width = Target->getPointerWidth(AS); |
| Align = Target->getPointerAlign(AS); |
| break; |
| case Type::MemberPointer: { |
| const auto *MPT = cast<MemberPointerType>(T); |
| CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT); |
| Width = MPI.Width; |
| Align = MPI.Align; |
| break; |
| } |
| case Type::Complex: { |
| // Complex types have the same alignment as their elements, but twice the |
| // size. |
| TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType()); |
| Width = EltInfo.Width * 2; |
| Align = EltInfo.Align; |
| break; |
| } |
| case Type::ObjCObject: |
| return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); |
| case Type::Adjusted: |
| case Type::Decayed: |
| return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr()); |
| case Type::ObjCInterface: { |
| const auto *ObjCI = cast<ObjCInterfaceType>(T); |
| const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); |
| Width = toBits(Layout.getSize()); |
| Align = toBits(Layout.getAlignment()); |
| break; |
| } |
| case Type::Record: |
| case Type::Enum: { |
| const auto *TT = cast<TagType>(T); |
| |
| if (TT->getDecl()->isInvalidDecl()) { |
| Width = 8; |
| Align = 8; |
| break; |
| } |
| |
| if (const auto *ET = dyn_cast<EnumType>(TT)) { |
| const EnumDecl *ED = ET->getDecl(); |
| TypeInfo Info = |
| getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType()); |
| if (unsigned AttrAlign = ED->getMaxAlignment()) { |
| Info.Align = AttrAlign; |
| Info.AlignIsRequired = true; |
| } |
| return Info; |
| } |
| |
| const auto *RT = cast<RecordType>(TT); |
| const RecordDecl *RD = RT->getDecl(); |
| const ASTRecordLayout &Layout = getASTRecordLayout(RD); |
| Width = toBits(Layout.getSize()); |
| Align = toBits(Layout.getAlignment()); |
| AlignIsRequired = RD->hasAttr<AlignedAttr>(); |
| break; |
| } |
| |
| case Type::SubstTemplateTypeParm: |
| return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> |
| getReplacementType().getTypePtr()); |
| |
| case Type::Auto: |
| case Type::DeducedTemplateSpecialization: { |
| const auto *A = cast<DeducedType>(T); |
| assert(!A->getDeducedType().isNull() && |
| "cannot request the size of an undeduced or dependent auto type"); |
| return getTypeInfo(A->getDeducedType().getTypePtr()); |
| } |
| |
| case Type::Paren: |
| return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); |
| |
| case Type::MacroQualified: |
| return getTypeInfo( |
| cast<MacroQualifiedType>(T)->getUnderlyingType().getTypePtr()); |
| |
| case Type::ObjCTypeParam: |
| return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr()); |
| |
| case Type::Typedef: { |
| const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); |
| TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); |
| // If the typedef has an aligned attribute on it, it overrides any computed |
| // alignment we have. This violates the GCC documentation (which says that |
| // attribute(aligned) can only round up) but matches its implementation. |
| if (unsigned AttrAlign = Typedef->getMaxAlignment()) { |
| Align = AttrAlign; |
| AlignIsRequired = true; |
| } else { |
| Align = Info.Align; |
| AlignIsRequired = Info.AlignIsRequired; |
| } |
| Width = Info.Width; |
| break; |
| } |
| |
| case Type::Elaborated: |
| return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); |
| |
| case Type::Attributed: |
| return getTypeInfo( |
| cast<AttributedType>(T)->getEquivalentType().getTypePtr()); |
| |
| case Type::Atomic: { |
| // Start with the base type information. |
| TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType()); |
| Width = Info.Width; |
| Align = Info.Align; |
| |
| if (!Width) { |
| // An otherwise zero-sized type should still generate an |
| // atomic operation. |
| Width = Target->getCharWidth(); |
| assert(Align); |
| } else if (Width <= Target->getMaxAtomicPromoteWidth()) { |
| // If the size of the type doesn't exceed the platform's max |
| // atomic promotion width, make the size and alignment more |
| // favorable to atomic operations: |
| |
| // Round the size up to a power of 2. |
| if (!llvm::isPowerOf2_64(Width)) |
| Width = llvm::NextPowerOf2(Width); |
| |
| // Set the alignment equal to the size. |
| Align = static_cast<unsigned>(Width); |
| } |
| } |
| break; |
| |
| case Type::Pipe: |
| Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global)); |
| Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global)); |
| break; |
| } |
| |
| assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); |
| return TypeInfo(Width, Align, AlignIsRequired); |
| } |
| |
| unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const { |
| UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T); |
| if (I != MemoizedUnadjustedAlign.end()) |
| return I->second; |
| |
| unsigned UnadjustedAlign; |
| if (const auto *RT = T->getAs<RecordType>()) { |
| const RecordDecl *RD = RT->getDecl(); |
| const ASTRecordLayout &Layout = getASTRecordLayout(RD); |
| UnadjustedAlign = toBits(Layout.getUnadjustedAlignment()); |
| } else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) { |
| const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); |
| UnadjustedAlign = toBits(Layout.getUnadjustedAlignment()); |
| } else { |
| UnadjustedAlign = getTypeAlign(T->getUnqualifiedDesugaredType()); |
| } |
| |
| MemoizedUnadjustedAlign[T] = UnadjustedAlign; |
| return UnadjustedAlign; |
| } |
| |
| unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const { |
| unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign(); |
| // Target ppc64 with QPX: simd default alignment for pointer to double is 32. |
| if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 || |
| getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) && |
| getTargetInfo().getABI() == "elfv1-qpx" && |
| T->isSpecificBuiltinType(BuiltinType::Double)) |
| SimdAlign = 256; |
| return SimdAlign; |
| } |
| |
| /// toCharUnitsFromBits - Convert a size in bits to a size in characters. |
| CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { |
| return CharUnits::fromQuantity(BitSize / getCharWidth()); |
| } |
| |
| /// toBits - Convert a size in characters to a size in characters. |
| int64_t ASTContext::toBits(CharUnits CharSize) const { |
| return CharSize.getQuantity() * getCharWidth(); |
| } |
| |
| /// getTypeSizeInChars - Return the size of the specified type, in characters. |
| /// This method does not work on incomplete types. |
| CharUnits ASTContext::getTypeSizeInChars(QualType T) const { |
| return getTypeInfoInChars(T).first; |
| } |
| CharUnits ASTContext::getTypeSizeInChars(const Type *T) const { |
| return getTypeInfoInChars(T).first; |
| } |
| |
| /// getTypeAlignInChars - Return the ABI-specified alignment of a type, in |
| /// characters. This method does not work on incomplete types. |
| CharUnits ASTContext::getTypeAlignInChars(QualType T) const { |
| return toCharUnitsFromBits(getTypeAlign(T)); |
| } |
| CharUnits ASTContext::getTypeAlignInChars(const Type *T) const { |
| return toCharUnitsFromBits(getTypeAlign(T)); |
| } |
| |
| /// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a |
| /// type, in characters, before alignment adustments. This method does |
| /// not work on incomplete types. |
| CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const { |
| return toCharUnitsFromBits(getTypeUnadjustedAlign(T)); |
| } |
| CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const { |
| return toCharUnitsFromBits(getTypeUnadjustedAlign(T)); |
| } |
| |
| /// getPreferredTypeAlign - Return the "preferred" alignment of the specified |
| /// type for the current target in bits. This can be different than the ABI |
| /// alignment in cases where it is beneficial for performance to overalign |
| /// a data type. |
| unsigned ASTContext::getPreferredTypeAlign(const Type *T) const { |
| TypeInfo TI = getTypeInfo(T); |
| unsigned ABIAlign = TI.Align; |
| |
| T = T->getBaseElementTypeUnsafe(); |
| |
| // The preferred alignment of member pointers is that of a pointer. |
| if (T->isMemberPointerType()) |
| return getPreferredTypeAlign(getPointerDiffType().getTypePtr()); |
| |
| if (!Target->allowsLargerPreferedTypeAlignment()) |
| return ABIAlign; |
| |
| // Double and long long should be naturally aligned if possible. |
| if (const auto *CT = T->getAs<ComplexType>()) |
| T = CT->getElementType().getTypePtr(); |
| if (const auto *ET = T->getAs<EnumType>()) |
| T = ET->getDecl()->getIntegerType().getTypePtr(); |
| if (T->isSpecificBuiltinType(BuiltinType::Double) || |
| T->isSpecificBuiltinType(BuiltinType::LongLong) || |
| T->isSpecificBuiltinType(BuiltinType::ULongLong)) |
| // Don't increase the alignment if an alignment attribute was specified on a |
| // typedef declaration. |
| if (!TI.AlignIsRequired) |
| return std::max(ABIAlign, (unsigned)getTypeSize(T)); |
| |
| return ABIAlign; |
| } |
| |
| /// getTargetDefaultAlignForAttributeAligned - Return the default alignment |
| /// for __attribute__((aligned)) on this target, to be used if no alignment |
| /// value is specified. |
| unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const { |
| return getTargetInfo().getDefaultAlignForAttributeAligned(); |
| } |
| |
| /// getAlignOfGlobalVar - Return the alignment in bits that should be given |
| /// to a global variable of the specified type. |
| unsigned ASTContext::getAlignOfGlobalVar(QualType T) const { |
| uint64_t TypeSize = getTypeSize(T.getTypePtr()); |
| return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign(TypeSize)); |
| } |
| |
| /// getAlignOfGlobalVarInChars - Return the alignment in characters that |
| /// should be given to a global variable of the specified type. |
| CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const { |
| return toCharUnitsFromBits(getAlignOfGlobalVar(T)); |
| } |
| |
| CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const { |
| CharUnits Offset = CharUnits::Zero(); |
| const ASTRecordLayout *Layout = &getASTRecordLayout(RD); |
| while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) { |
| Offset += Layout->getBaseClassOffset(Base); |
| Layout = &getASTRecordLayout(Base); |
| } |
| return Offset; |
| } |
| |
| /// DeepCollectObjCIvars - |
| /// This routine first collects all declared, but not synthesized, ivars in |
| /// super class and then collects all ivars, including those synthesized for |
| /// current class. This routine is used for implementation of current class |
| /// when all ivars, declared and synthesized are known. |
| void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, |
| bool leafClass, |
| SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { |
| if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) |
| DeepCollectObjCIvars(SuperClass, false, Ivars); |
| if (!leafClass) { |
| for (const auto *I : OI->ivars()) |
| Ivars.push_back(I); |
| } else { |
| auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI); |
| for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; |
| Iv= Iv->getNextIvar()) |
| Ivars.push_back(Iv); |
| } |
| } |
| |
| /// CollectInheritedProtocols - Collect all protocols in current class and |
| /// those inherited by it. |
| void ASTContext::CollectInheritedProtocols(const Decl *CDecl, |
| llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { |
| if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { |
| // We can use protocol_iterator here instead of |
| // all_referenced_protocol_iterator since we are walking all categories. |
| for (auto *Proto : OI->all_referenced_protocols()) { |
| CollectInheritedProtocols(Proto, Protocols); |
| } |
| |
| // Categories of this Interface. |
| for (const auto *Cat : OI->visible_categories()) |
| CollectInheritedProtocols(Cat, Protocols); |
| |
| if (ObjCInterfaceDecl *SD = OI->getSuperClass()) |
| while (SD) { |
| CollectInheritedProtocols(SD, Protocols); |
| SD = SD->getSuperClass(); |
| } |
| } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { |
| for (auto *Proto : OC->protocols()) { |
| CollectInheritedProtocols(Proto, Protocols); |
| } |
| } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { |
| // Insert the protocol. |
| if (!Protocols.insert( |
| const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second) |
| return; |
| |
| for (auto *Proto : OP->protocols()) |
| CollectInheritedProtocols(Proto, Protocols); |
| } |
| } |
| |
| static bool unionHasUniqueObjectRepresentations(const ASTContext &Context, |
| const RecordDecl *RD) { |
| assert(RD->isUnion() && "Must be union type"); |
| CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl()); |
| |
| for (const auto *Field : RD->fields()) { |
| if (!Context.hasUniqueObjectRepresentations(Field->getType())) |
| return false; |
| CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType()); |
| if (FieldSize != UnionSize) |
| return false; |
| } |
| return !RD->field_empty(); |
| } |
| |
| static bool isStructEmpty(QualType Ty) { |
| const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl(); |
| |
| if (!RD->field_empty()) |
| return false; |
| |
| if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) |
| return ClassDecl->isEmpty(); |
| |
| return true; |
| } |
| |
| static llvm::Optional<int64_t> |
| structHasUniqueObjectRepresentations(const ASTContext &Context, |
| const RecordDecl *RD) { |
| assert(!RD->isUnion() && "Must be struct/class type"); |
| const auto &Layout = Context.getASTRecordLayout(RD); |
| |
| int64_t CurOffsetInBits = 0; |
| if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) { |
| if (ClassDecl->isDynamicClass()) |
| return llvm::None; |
| |
| SmallVector<std::pair<QualType, int64_t>, 4> Bases; |
| for (const auto Base : ClassDecl->bases()) { |
| // Empty types can be inherited from, and non-empty types can potentially |
| // have tail padding, so just make sure there isn't an error. |
| if (!isStructEmpty(Base.getType())) { |
| llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations( |
| Context, Base.getType()->castAs<RecordType>()->getDecl()); |
| if (!Size) |
| return llvm::None; |
| Bases.emplace_back(Base.getType(), Size.getValue()); |
| } |
| } |
| |
| llvm::sort(Bases, [&](const std::pair<QualType, int64_t> &L, |
| const std::pair<QualType, int64_t> &R) { |
| return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) < |
| Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl()); |
| }); |
| |
| for (const auto Base : Bases) { |
| int64_t BaseOffset = Context.toBits( |
| Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl())); |
| int64_t BaseSize = Base.second; |
| if (BaseOffset != CurOffsetInBits) |
| return llvm::None; |
| CurOffsetInBits = BaseOffset + BaseSize; |
| } |
| } |
| |
| for (const auto *Field : RD->fields()) { |
| if (!Field->getType()->isReferenceType() && |
| !Context.hasUniqueObjectRepresentations(Field->getType())) |
| return llvm::None; |
| |
| int64_t FieldSizeInBits = |
| Context.toBits(Context.getTypeSizeInChars(Field->getType())); |
| if (Field->isBitField()) { |
| int64_t BitfieldSize = Field->getBitWidthValue(Context); |
| |
| if (BitfieldSize > FieldSizeInBits) |
| return llvm::None; |
| FieldSizeInBits = BitfieldSize; |
| } |
| |
| int64_t FieldOffsetInBits = Context.getFieldOffset(Field); |
| |
| if (FieldOffsetInBits != CurOffsetInBits) |
| return llvm::None; |
| |
| CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits; |
| } |
| |
| return CurOffsetInBits; |
| } |
| |
| bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const { |
| // C++17 [meta.unary.prop]: |
| // The predicate condition for a template specialization |
| // has_unique_object_representations<T> shall be |
| // satisfied if and only if: |
| // (9.1) - T is trivially copyable, and |
| // (9.2) - any two objects of type T with the same value have the same |
| // object representation, where two objects |
| // of array or non-union class type are considered to have the same value |
| // if their respective sequences of |
| // direct subobjects have the same values, and two objects of union type |
| // are considered to have the same |
| // value if they have the same active member and the corresponding members |
| // have the same value. |
| // The set of scalar types for which this condition holds is |
| // implementation-defined. [ Note: If a type has padding |
| // bits, the condition does not hold; otherwise, the condition holds true |
| // for unsigned integral types. -- end note ] |
| assert(!Ty.isNull() && "Null QualType sent to unique object rep check"); |
| |
| // Arrays are unique only if their element type is unique. |
| if (Ty->isArrayType()) |
| return hasUniqueObjectRepresentations(getBaseElementType(Ty)); |
| |
| // (9.1) - T is trivially copyable... |
| if (!Ty.isTriviallyCopyableType(*this)) |
| return false; |
| |
| // All integrals and enums are unique. |
| if (Ty->isIntegralOrEnumerationType()) |
| return true; |
| |
| // All other pointers are unique. |
| if (Ty->isPointerType()) |
| return true; |
| |
| if (Ty->isMemberPointerType()) { |
| const auto *MPT = Ty->getAs<MemberPointerType>(); |
| return !ABI->getMemberPointerInfo(MPT).HasPadding; |
| } |
| |
| if (Ty->isRecordType()) { |
| const RecordDecl *Record = Ty->castAs<RecordType>()->getDecl(); |
| |
| if (Record->isInvalidDecl()) |
| return false; |
| |
| if (Record->isUnion()) |
| return unionHasUniqueObjectRepresentations(*this, Record); |
| |
| Optional<int64_t> StructSize = |
| structHasUniqueObjectRepresentations(*this, Record); |
| |
| return StructSize && |
| StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty)); |
| } |
| |
| // FIXME: More cases to handle here (list by rsmith): |
| // vectors (careful about, eg, vector of 3 foo) |
| // _Complex int and friends |
| // _Atomic T |
| // Obj-C block pointers |
| // Obj-C object pointers |
| // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t, |
| // clk_event_t, queue_t, reserve_id_t) |
| // There're also Obj-C class types and the Obj-C selector type, but I think it |
| // makes sense for those to return false here. |
| |
| return false; |
| } |
| |
| unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { |
| unsigned count = 0; |
| // Count ivars declared in class extension. |
| for (const auto *Ext : OI->known_extensions()) |
| count += Ext->ivar_size(); |
| |
| // Count ivar defined in this class's implementation. This |
| // includes synthesized ivars. |
| if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) |
| count += ImplDecl->ivar_size(); |
| |
| return count; |
| } |
| |
| bool ASTContext::isSentinelNullExpr(const Expr *E) { |
| if (!E) |
| return false; |
| |
| // nullptr_t is always treated as null. |
| if (E->getType()->isNullPtrType()) return true; |
| |
| if (E->getType()->isAnyPointerType() && |
| E->IgnoreParenCasts()->isNullPointerConstant(*this, |
| Expr::NPC_ValueDependentIsNull)) |
| return true; |
| |
| // Unfortunately, __null has type 'int'. |
| if (isa<GNUNullExpr>(E)) return true; |
| |
| return false; |
| } |
| |
| /// Get the implementation of ObjCInterfaceDecl, or nullptr if none |
| /// exists. |
| ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { |
| llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator |
| I = ObjCImpls.find(D); |
| if (I != ObjCImpls.end()) |
| return cast<ObjCImplementationDecl>(I->second); |
| return nullptr; |
| } |
| |
| /// Get the implementation of ObjCCategoryDecl, or nullptr if none |
| /// exists. |
| ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { |
| llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator |
| I = ObjCImpls.find(D); |
| if (I != ObjCImpls.end()) |
| return cast<ObjCCategoryImplDecl>(I->second); |
| return nullptr; |
| } |
| |
| /// Set the implementation of ObjCInterfaceDecl. |
| void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, |
| ObjCImplementationDecl *ImplD) { |
| assert(IFaceD && ImplD && "Passed null params"); |
| ObjCImpls[IFaceD] = ImplD; |
| } |
| |
| /// Set the implementation of ObjCCategoryDecl. |
| void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, |
| ObjCCategoryImplDecl *ImplD) { |
| assert(CatD && ImplD && "Passed null params"); |
| ObjCImpls[CatD] = ImplD; |
| } |
| |
| const ObjCMethodDecl * |
| ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const { |
| return ObjCMethodRedecls.lookup(MD); |
| } |
| |
| void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD, |
| const ObjCMethodDecl *Redecl) { |
| assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration"); |
| ObjCMethodRedecls[MD] = Redecl; |
| } |
| |
| const ObjCInterfaceDecl *ASTContext::getObjContainingInterface( |
| const NamedDecl *ND) const { |
| if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) |
| return ID; |
| if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) |
| return CD->getClassInterface(); |
| if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) |
| return IMD->getClassInterface(); |
| |
| return nullptr; |
| } |
| |
| /// Get the copy initialization expression of VarDecl, or nullptr if |
| /// none exists. |
| ASTContext::BlockVarCopyInit |
| ASTContext::getBlockVarCopyInit(const VarDecl*VD) const { |
| assert(VD && "Passed null params"); |
| assert(VD->hasAttr<BlocksAttr>() && |
| "getBlockVarCopyInits - not __block var"); |
| auto I = BlockVarCopyInits.find(VD); |
| if (I != BlockVarCopyInits.end()) |
| return I->second; |
| return {nullptr, false}; |
| } |
| |
| /// Set the copy initialization expression of a block var decl. |
| void ASTContext::setBlockVarCopyInit(<
|