r310436 - [AST] Move visibility computations into a class; NFC
George Burgess IV via cfe-commits
cfe-commits at lists.llvm.org
Wed Aug 9 14:22:18 PDT 2017
Sorry about that!
Attempted fix is r310523. I'll keep an eye on the bot to make sure it
turns green.
On Wed, Aug 9, 2017 at 1:23 PM, Juergen Ributzka <juergen at ributzka.de> wrote:
> This seems to cause UBSAN issues:
>
> runtime error: load of value 4294967295, which is not a valid value for type
> 'clang::LVComputationKind'
>
> See ASAN+UBSAN bot on Green Dragon:
> http://lab.llvm.org:8080/green/job/clang-stage2-cmake-RgSan_check/4065/console
>
> On Tue, Aug 8, 2017 at 9:02 PM, George Burgess IV via cfe-commits
> <cfe-commits at lists.llvm.org> wrote:
>>
>> Author: gbiv
>> Date: Tue Aug 8 21:02:49 2017
>> New Revision: 310436
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=310436&view=rev
>> Log:
>> [AST] Move visibility computations into a class; NFC
>>
>> This is patch 1 in a 2 patch series that aims to fix PR29160. Its goal
>> is to cache decl visibility/linkage for the duration of each
>> visibility+linkage query.
>>
>> The simplest way I can see to do this is to put the visibility
>> calculation code that needs to (transitively) access this cache into a
>> class, which is what this patch does. Actual caching will come in patch
>> 2. (Another way would be to keep the cache in ASTContext + manually
>> invalidate it or something, but that felt way too subtle to me.)
>>
>> Caching visibility results across multiple queries seems a bit tricky,
>> since the user can add visibility attributes ~whenever they want, and
>> these attributes can apparently have far-reaching effects (e.g. class
>> visibility extends to its members, ...). Because a cache that's dropped
>> at the end of each top-level query seems to work nearly as well and
>> doesn't require any eviction logic, I opted for that design.
>>
>> Added:
>> cfe/trunk/lib/AST/Linkage.h
>> Modified:
>> cfe/trunk/lib/AST/Decl.cpp
>> cfe/trunk/lib/AST/Type.cpp
>>
>> Modified: cfe/trunk/lib/AST/Decl.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Decl.cpp?rev=310436&r1=310435&r2=310436&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/Decl.cpp (original)
>> +++ cfe/trunk/lib/AST/Decl.cpp Tue Aug 8 21:02:49 2017
>> @@ -12,6 +12,7 @@
>>
>> //===----------------------------------------------------------------------===//
>>
>> #include "clang/AST/Decl.h"
>> +#include "Linkage.h"
>> #include "clang/AST/ASTContext.h"
>> #include "clang/AST/ASTLambda.h"
>> #include "clang/AST/ASTMutationListener.h"
>> @@ -99,38 +100,6 @@ TranslationUnitDecl::TranslationUnitDecl
>> // and 'matcher' is a type only matters when looking for attributes
>> // and settings from the immediate context.
>>
>> -const static unsigned IgnoreExplicitVisibilityBit = 2;
>> -const static unsigned IgnoreAllVisibilityBit = 4;
>> -
>> -/// Kinds of LV computation. The linkage side of the computation is
>> -/// always the same, but different things can change how visibility is
>> -/// computed.
>> -enum LVComputationKind {
>> - /// Do an LV computation for, ultimately, a type.
>> - /// Visibility may be restricted by type visibility settings and
>> - /// the visibility of template arguments.
>> - LVForType = NamedDecl::VisibilityForType,
>> -
>> - /// Do an LV computation for, ultimately, a non-type declaration.
>> - /// Visibility may be restricted by value visibility settings and
>> - /// the visibility of template arguments.
>> - LVForValue = NamedDecl::VisibilityForValue,
>> -
>> - /// Do an LV computation for, ultimately, a type that already has
>> - /// some sort of explicit visibility. Visibility may only be
>> - /// restricted by the visibility of template arguments.
>> - LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit),
>> -
>> - /// Do an LV computation for, ultimately, a non-type declaration
>> - /// that already has some sort of explicit visibility. Visibility
>> - /// may only be restricted by the visibility of template arguments.
>> - LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit),
>> -
>> - /// Do an LV computation when we only care about the linkage.
>> - LVForLinkageOnly =
>> - LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit
>> -};
>> -
>> /// Does this computation kind permit us to consider additional
>> /// visibility settings from attributes and the like?
>> static bool hasExplicitVisibilityAlready(LVComputationKind computation) {
>> @@ -219,8 +188,8 @@ static Optional<Visibility> getVisibilit
>> return None;
>> }
>>
>> -static LinkageInfo
>> -getLVForType(const Type &T, LVComputationKind computation) {
>> +LinkageInfo LinkageComputer::getLVForType(const Type &T,
>> + LVComputationKind computation)
>> {
>> if (computation == LVForLinkageOnly)
>> return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
>> return T.getLinkageAndVisibility();
>> @@ -229,9 +198,8 @@ getLVForType(const Type &T, LVComputatio
>> /// \brief Get the most restrictive linkage for the types in the given
>> /// template parameter list. For visibility purposes, template
>> /// parameters are part of the signature of a template.
>> -static LinkageInfo
>> -getLVForTemplateParameterList(const TemplateParameterList *Params,
>> - LVComputationKind computation) {
>> +LinkageInfo LinkageComputer::getLVForTemplateParameterList(
>> + const TemplateParameterList *Params, LVComputationKind computation) {
>> LinkageInfo LV;
>> for (const NamedDecl *P : *Params) {
>> // Template type parameters are the most common and never
>> @@ -283,10 +251,6 @@ getLVForTemplateParameterList(const Temp
>> return LV;
>> }
>>
>> -/// getLVForDecl - Get the linkage and visibility for the given
>> declaration.
>> -static LinkageInfo getLVForDecl(const NamedDecl *D,
>> - LVComputationKind computation);
>> -
>> static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
>> const Decl *Ret = nullptr;
>> const DeclContext *DC = D->getDeclContext();
>> @@ -303,8 +267,9 @@ static const Decl *getOutermostFuncOrBlo
>> ///
>> /// Note that we don't take an LVComputationKind because we always
>> /// want to honor the visibility of template arguments in the same way.
>> -static LinkageInfo
>> getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
>> - LVComputationKind
>> computation) {
>> +LinkageInfo
>> +LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument>
>> Args,
>> + LVComputationKind
>> computation) {
>> LinkageInfo LV;
>>
>> for (const TemplateArgument &Arg : Args) {
>> @@ -346,9 +311,9 @@ static LinkageInfo getLVForTemplateArgum
>> return LV;
>> }
>>
>> -static LinkageInfo
>> -getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
>> - LVComputationKind computation) {
>> +LinkageInfo
>> +LinkageComputer::getLVForTemplateArgumentList(const TemplateArgumentList
>> &TArgs,
>> + LVComputationKind
>> computation) {
>> return getLVForTemplateArgumentList(TArgs.asArray(), computation);
>> }
>>
>> @@ -371,10 +336,10 @@ static bool shouldConsiderTemplateVisibi
>> /// LVForValue.
>> ///
>> /// \param[out] LV the computation to use for the parent
>> -static void
>> -mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn,
>> - const FunctionTemplateSpecializationInfo *specInfo,
>> - LVComputationKind computation) {
>> +void LinkageComputer::mergeTemplateLV(
>> + LinkageInfo &LV, const FunctionDecl *fn,
>> + const FunctionTemplateSpecializationInfo *specInfo,
>> + LVComputationKind computation) {
>> bool considerVisibility =
>> shouldConsiderTemplateVisibility(fn, specInfo);
>>
>> @@ -449,9 +414,9 @@ static bool shouldConsiderTemplateVisibi
>>
>> /// Merge in template-related linkage and visibility for the given
>> /// class template specialization.
>> -static void mergeTemplateLV(LinkageInfo &LV,
>> - const ClassTemplateSpecializationDecl *spec,
>> - LVComputationKind computation) {
>> +void LinkageComputer::mergeTemplateLV(
>> + LinkageInfo &LV, const ClassTemplateSpecializationDecl *spec,
>> + LVComputationKind computation) {
>> bool considerVisibility = shouldConsiderTemplateVisibility(spec,
>> computation);
>>
>> // Merge information from the template parameters, but ignore
>> @@ -501,9 +466,9 @@ static bool shouldConsiderTemplateVisibi
>> /// Merge in template-related linkage and visibility for the given
>> /// variable template specialization. As usual, follow class template
>> /// specialization logic up to initialization.
>> -static void mergeTemplateLV(LinkageInfo &LV,
>> - const VarTemplateSpecializationDecl *spec,
>> - LVComputationKind computation) {
>> +void LinkageComputer::mergeTemplateLV(LinkageInfo &LV,
>> + const VarTemplateSpecializationDecl
>> *spec,
>> + LVComputationKind computation) {
>> bool considerVisibility = shouldConsiderTemplateVisibility(spec,
>> computation);
>>
>> // Merge information from the template parameters, but ignore
>> @@ -603,8 +568,9 @@ static LinkageInfo getExternalLinkageFor
>> return LinkageInfo::external();
>> }
>>
>> -static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
>> - LVComputationKind
>> computation) {
>> +LinkageInfo
>> +LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
>> + LVComputationKind
>> computation) {
>> assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
>> "Not a name having namespace scope");
>> ASTContext &Context = D->getASTContext();
>> @@ -883,8 +849,9 @@ static LinkageInfo getLVForNamespaceScop
>> return LV;
>> }
>>
>> -static LinkageInfo getLVForClassMember(const NamedDecl *D,
>> - LVComputationKind computation) {
>> +LinkageInfo
>> +LinkageComputer::getLVForClassMember(const NamedDecl *D,
>> + LVComputationKind computation) {
>> // Only certain class members have linkage. Note that fields don't
>> // really have linkage, but it's convenient to say they do for the
>> // purposes of calculating linkage of pointer-to-data-member
>> @@ -1041,15 +1008,13 @@ static LinkageInfo getLVForClassMember(c
>>
>> void NamedDecl::anchor() { }
>>
>> -static LinkageInfo computeLVForDecl(const NamedDecl *D,
>> - LVComputationKind computation);
>> -
>> bool NamedDecl::isLinkageValid() const {
>> if (!hasCachedLinkage())
>> return true;
>>
>> - return computeLVForDecl(this, LVForLinkageOnly).getLinkage() ==
>> - getCachedLinkage();
>> + Linkage L =
>> + LinkageComputer{}.computeLVForDecl(this,
>> LVForLinkageOnly).getLinkage();
>> + return L == getCachedLinkage();
>> }
>>
>> ObjCStringFormatFamily NamedDecl::getObjCFStringFormattingFamily() const
>> {
>> @@ -1068,13 +1033,11 @@ ObjCStringFormatFamily NamedDecl::getObj
>> Linkage NamedDecl::getLinkageInternal() const {
>> // We don't care about visibility here, so ask for the cheapest
>> // possible visibility analysis.
>> - return getLVForDecl(this, LVForLinkageOnly).getLinkage();
>> + return LinkageComputer{}.getLVForDecl(this,
>> LVForLinkageOnly).getLinkage();
>> }
>>
>> LinkageInfo NamedDecl::getLinkageAndVisibility() const {
>> - LVComputationKind computation =
>> - (usesTypeVisibility(this) ? LVForType : LVForValue);
>> - return getLVForDecl(this, computation);
>> + return LinkageComputer{}.getDeclLinkageAndVisibility(this);
>> }
>>
>> static Optional<Visibility>
>> @@ -1152,8 +1115,9 @@ NamedDecl::getExplicitVisibility(Explici
>> return getExplicitVisibilityAux(this, kind, false);
>> }
>>
>> -static LinkageInfo getLVForClosure(const DeclContext *DC, Decl
>> *ContextDecl,
>> - LVComputationKind computation) {
>> +LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
>> + Decl *ContextDecl,
>> + LVComputationKind
>> computation) {
>> // This lambda has its linkage/visibility determined by its owner.
>> if (ContextDecl) {
>> if (isa<ParmVarDecl>(ContextDecl))
>> @@ -1170,8 +1134,8 @@ static LinkageInfo getLVForClosure(const
>> return LinkageInfo::external();
>> }
>>
>> -static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
>> - LVComputationKind computation) {
>> +LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
>> + LVComputationKind
>> computation) {
>> if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
>> if (Function->isInAnonymousNamespace() &&
>> !Function->isInExternCContext())
>> @@ -1264,8 +1228,8 @@ getOutermostEnclosingLambda(const CXXRec
>> return Ret;
>> }
>>
>> -static LinkageInfo computeLVForDecl(const NamedDecl *D,
>> - LVComputationKind computation) {
>> +LinkageInfo LinkageComputer::computeLVForDecl(const NamedDecl *D,
>> + LVComputationKind
>> computation) {
>> // Internal_linkage attribute overrides other considerations.
>> if (D->hasAttr<InternalLinkageAttr>())
>> return getInternalLinkageFor(D);
>> @@ -1384,56 +1348,51 @@ static LinkageInfo computeLVForDecl(cons
>> return LinkageInfo::none();
>> }
>>
>> -namespace clang {
>> -class LinkageComputer {
>> -public:
>> - static LinkageInfo getLVForDecl(const NamedDecl *D,
>> - LVComputationKind computation) {
>> - // Internal_linkage attribute overrides other considerations.
>> - if (D->hasAttr<InternalLinkageAttr>())
>> - return getInternalLinkageFor(D);
>> -
>> - if (computation == LVForLinkageOnly && D->hasCachedLinkage())
>> - return LinkageInfo(D->getCachedLinkage(), DefaultVisibility,
>> false);
>> -
>> - LinkageInfo LV = computeLVForDecl(D, computation);
>> - if (D->hasCachedLinkage())
>> - assert(D->getCachedLinkage() == LV.getLinkage());
>> +/// getLVForDecl - Get the linkage and visibility for the given
>> declaration.
>> +LinkageInfo LinkageComputer::getLVForDecl(const NamedDecl *D,
>> + LVComputationKind computation)
>> {
>> + // Internal_linkage attribute overrides other considerations.
>> + if (D->hasAttr<InternalLinkageAttr>())
>> + return getInternalLinkageFor(D);
>> +
>> + if (computation == LVForLinkageOnly && D->hasCachedLinkage())
>> + return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
>>
>> - D->setCachedLinkage(LV.getLinkage());
>> + LinkageInfo LV = computeLVForDecl(D, computation);
>> + if (D->hasCachedLinkage())
>> + assert(D->getCachedLinkage() == LV.getLinkage());
>> +
>> + D->setCachedLinkage(LV.getLinkage());
>>
>> #ifndef NDEBUG
>> - // In C (because of gnu inline) and in c++ with microsoft extensions
>> an
>> - // static can follow an extern, so we can have two decls with
>> different
>> - // linkages.
>> - const LangOptions &Opts = D->getASTContext().getLangOpts();
>> - if (!Opts.CPlusPlus || Opts.MicrosoftExt)
>> - return LV;
>> + // In C (because of gnu inline) and in c++ with microsoft extensions an
>> + // static can follow an extern, so we can have two decls with different
>> + // linkages.
>> + const LangOptions &Opts = D->getASTContext().getLangOpts();
>> + if (!Opts.CPlusPlus || Opts.MicrosoftExt)
>> + return LV;
>>
>> - // We have just computed the linkage for this decl. By induction we
>> know
>> - // that all other computed linkages match, check that the one we just
>> - // computed also does.
>> - NamedDecl *Old = nullptr;
>> - for (auto I : D->redecls()) {
>> - auto *T = cast<NamedDecl>(I);
>> - if (T == D)
>> - continue;
>> - if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
>> - Old = T;
>> - break;
>> - }
>> + // We have just computed the linkage for this decl. By induction we
>> know
>> + // that all other computed linkages match, check that the one we just
>> + // computed also does.
>> + NamedDecl *Old = nullptr;
>> + for (auto I : D->redecls()) {
>> + auto *T = cast<NamedDecl>(I);
>> + if (T == D)
>> + continue;
>> + if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
>> + Old = T;
>> + break;
>> }
>> - assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
>> + }
>> + assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
>> #endif
>>
>> - return LV;
>> - }
>> -};
>> + return LV;
>> }
>>
>> -static LinkageInfo getLVForDecl(const NamedDecl *D,
>> - LVComputationKind computation) {
>> - return clang::LinkageComputer::getLVForDecl(D, computation);
>> +LinkageInfo LinkageComputer::getDeclLinkageAndVisibility(const NamedDecl
>> *D) {
>> + return getLVForDecl(D, usesTypeVisibility(D) ? LVForType : LVForValue);
>> }
>>
>> void NamedDecl::printName(raw_ostream &os) const {
>>
>> Added: cfe/trunk/lib/AST/Linkage.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Linkage.h?rev=310436&view=auto
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/Linkage.h (added)
>> +++ cfe/trunk/lib/AST/Linkage.h Tue Aug 8 21:02:49 2017
>> @@ -0,0 +1,114 @@
>> +//===----- Linkage.h - Linkage calculation-related utilities ----*- C++
>> -*-===//
>> +//
>> +// The LLVM Compiler Infrastructure
>> +//
>> +// This file is distributed under the University of Illinois Open Source
>> +// License. See LICENSE.TXT for details.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +//
>> +// This file provides AST-internal utilities for linkage and visibility
>> +// calculation.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +#ifndef LLVM_CLANG_LIB_AST_LINKAGE_H
>> +#define LLVM_CLANG_LIB_AST_LINKAGE_H
>> +
>> +#include "clang/AST/Decl.h"
>> +#include "clang/AST/DeclCXX.h"
>> +#include "clang/AST/Type.h"
>> +#include "llvm/ADT/DenseMap.h"
>> +
>> +namespace clang {
>> +enum : unsigned {
>> + IgnoreExplicitVisibilityBit = 2,
>> + IgnoreAllVisibilityBit = 4
>> +};
>> +
>> +/// Kinds of LV computation. The linkage side of the computation is
>> +/// always the same, but different things can change how visibility is
>> +/// computed.
>> +enum LVComputationKind {
>> + /// Do an LV computation for, ultimately, a type.
>> + /// Visibility may be restricted by type visibility settings and
>> + /// the visibility of template arguments.
>> + LVForType = NamedDecl::VisibilityForType,
>> +
>> + /// Do an LV computation for, ultimately, a non-type declaration.
>> + /// Visibility may be restricted by value visibility settings and
>> + /// the visibility of template arguments.
>> + LVForValue = NamedDecl::VisibilityForValue,
>> +
>> + /// Do an LV computation for, ultimately, a type that already has
>> + /// some sort of explicit visibility. Visibility may only be
>> + /// restricted by the visibility of template arguments.
>> + LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit),
>> +
>> + /// Do an LV computation for, ultimately, a non-type declaration
>> + /// that already has some sort of explicit visibility. Visibility
>> + /// may only be restricted by the visibility of template arguments.
>> + LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit),
>> +
>> + /// Do an LV computation when we only care about the linkage.
>> + LVForLinkageOnly =
>> + LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit
>> +};
>> +
>> +class LinkageComputer {
>> + LinkageInfo getLVForTemplateArgumentList(ArrayRef<TemplateArgument>
>> Args,
>> + LVComputationKind
>> computation);
>> +
>> + LinkageInfo getLVForTemplateArgumentList(const TemplateArgumentList
>> &TArgs,
>> + LVComputationKind
>> computation);
>> +
>> + void mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn,
>> + const FunctionTemplateSpecializationInfo
>> *specInfo,
>> + LVComputationKind computation);
>> +
>> + void mergeTemplateLV(LinkageInfo &LV,
>> + const ClassTemplateSpecializationDecl *spec,
>> + LVComputationKind computation);
>> +
>> + void mergeTemplateLV(LinkageInfo &LV,
>> + const VarTemplateSpecializationDecl *spec,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForClassMember(const NamedDecl *D,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForLocalDecl(const NamedDecl *D,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForType(const Type &T, LVComputationKind computation);
>> +
>> + LinkageInfo getLVForTemplateParameterList(const TemplateParameterList
>> *Params,
>> + LVComputationKind
>> computation);
>> +
>> +public:
>> + LinkageInfo computeLVForDecl(const NamedDecl *D,
>> + LVComputationKind computation);
>> +
>> + LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind
>> computation);
>> +
>> + LinkageInfo computeTypeLinkageInfo(const Type *T);
>> + LinkageInfo computeTypeLinkageInfo(QualType T) {
>> + return computeTypeLinkageInfo(T.getTypePtr());
>> + }
>> +
>> + LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D);
>> +
>> + LinkageInfo getTypeLinkageAndVisibility(const Type *T);
>> + LinkageInfo getTypeLinkageAndVisibility(QualType T) {
>> + return getTypeLinkageAndVisibility(T.getTypePtr());
>> + }
>> +};
>> +} // namespace clang
>> +
>> +#endif
>>
>> Modified: cfe/trunk/lib/AST/Type.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Type.cpp?rev=310436&r1=310435&r2=310436&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/Type.cpp (original)
>> +++ cfe/trunk/lib/AST/Type.cpp Tue Aug 8 21:02:49 2017
>> @@ -12,6 +12,7 @@
>>
>> //===----------------------------------------------------------------------===//
>>
>> #include "clang/AST/Type.h"
>> +#include "Linkage.h"
>> #include "clang/AST/ASTContext.h"
>> #include "clang/AST/Attr.h"
>> #include "clang/AST/CharUnits.h"
>> @@ -3428,9 +3429,7 @@ bool Type::hasUnnamedOrLocalType() const
>> return TypeBits.hasLocalOrUnnamedType();
>> }
>>
>> -static LinkageInfo computeLinkageInfo(QualType T);
>> -
>> -static LinkageInfo computeLinkageInfo(const Type *T) {
>> +LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
>> switch (T->getTypeClass()) {
>> #define TYPE(Class,Base)
>> #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
>> @@ -3457,72 +3456,75 @@ static LinkageInfo computeLinkageInfo(co
>> return cast<TagType>(T)->getDecl()->getLinkageAndVisibility();
>>
>> case Type::Complex:
>> - return computeLinkageInfo(cast<ComplexType>(T)->getElementType());
>> + return
>> computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
>> case Type::Pointer:
>> - return computeLinkageInfo(cast<PointerType>(T)->getPointeeType());
>> + return
>> computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
>> case Type::BlockPointer:
>> - return
>> computeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
>> + return
>> computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
>> case Type::LValueReference:
>> case Type::RValueReference:
>> - return computeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
>> + return
>> computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
>> case Type::MemberPointer: {
>> const MemberPointerType *MPT = cast<MemberPointerType>(T);
>> - LinkageInfo LV = computeLinkageInfo(MPT->getClass());
>> - LV.merge(computeLinkageInfo(MPT->getPointeeType()));
>> + LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
>> + LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
>> return LV;
>> }
>> case Type::ConstantArray:
>> case Type::IncompleteArray:
>> case Type::VariableArray:
>> - return computeLinkageInfo(cast<ArrayType>(T)->getElementType());
>> + return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
>> case Type::Vector:
>> case Type::ExtVector:
>> - return computeLinkageInfo(cast<VectorType>(T)->getElementType());
>> + return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
>> case Type::FunctionNoProto:
>> - return computeLinkageInfo(cast<FunctionType>(T)->getReturnType());
>> + return
>> computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
>> case Type::FunctionProto: {
>> const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
>> - LinkageInfo LV = computeLinkageInfo(FPT->getReturnType());
>> + LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
>> for (const auto &ai : FPT->param_types())
>> - LV.merge(computeLinkageInfo(ai));
>> + LV.merge(computeTypeLinkageInfo(ai));
>> return LV;
>> }
>> case Type::ObjCInterface:
>> return
>> cast<ObjCInterfaceType>(T)->getDecl()->getLinkageAndVisibility();
>> case Type::ObjCObject:
>> - return computeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
>> + return
>> computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
>> case Type::ObjCObjectPointer:
>> - return
>> computeLinkageInfo(cast<ObjCObjectPointerType>(T)->getPointeeType());
>> + return computeTypeLinkageInfo(
>> + cast<ObjCObjectPointerType>(T)->getPointeeType());
>> case Type::Atomic:
>> - return computeLinkageInfo(cast<AtomicType>(T)->getValueType());
>> + return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
>> case Type::Pipe:
>> - return computeLinkageInfo(cast<PipeType>(T)->getElementType());
>> + return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
>> }
>>
>> llvm_unreachable("unhandled type class");
>> }
>>
>> -static LinkageInfo computeLinkageInfo(QualType T) {
>> - return computeLinkageInfo(T.getTypePtr());
>> -}
>> -
>> bool Type::isLinkageValid() const {
>> if (!TypeBits.isCacheValid())
>> return true;
>>
>> - return computeLinkageInfo(getCanonicalTypeInternal()).getLinkage() ==
>> - TypeBits.getLinkage();
>> + Linkage L = LinkageComputer{}
>> + .computeTypeLinkageInfo(getCanonicalTypeInternal())
>> + .getLinkage();
>> + return L == TypeBits.getLinkage();
>> }
>>
>> -LinkageInfo Type::getLinkageAndVisibility() const {
>> - if (!isCanonicalUnqualified())
>> - return computeLinkageInfo(getCanonicalTypeInternal());
>> +LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) {
>> + if (!T->isCanonicalUnqualified())
>> + return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
>>
>> - LinkageInfo LV = computeLinkageInfo(this);
>> - assert(LV.getLinkage() == getLinkage());
>> + LinkageInfo LV = computeTypeLinkageInfo(T);
>> + assert(LV.getLinkage() == T->getLinkage());
>> return LV;
>> }
>>
>> +LinkageInfo Type::getLinkageAndVisibility() const {
>> + return LinkageComputer{}.getTypeLinkageAndVisibility(this);
>> +}
>> +
>> Optional<NullabilityKind> Type::getNullability(const ASTContext &context)
>> const {
>> QualType type(this, 0);
>> do {
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
>
More information about the cfe-commits
mailing list