Revert r120808, my previous implementation of caching for the linkage

and visibility of declarations, because it was extremely messy and it
increased the size of NamedDecl.

An improved implementation is forthcoming.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@121012 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 4 insertions, 109 deletions

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index a8959b8d91..71bda4156f 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -526,57 +526,7 @@ static LinkageInfo getLVForClassMember(const NamedDecl *D, LVFlags F) {
 }
 
 LinkageInfo NamedDecl::getLinkageAndVisibility() const {
-  // If we have already cached linkage and visibility, just return the
-  // cached information.
-  if (HasLinkageAndVisibilityCached) {
-#ifndef NDEBUG
-    LinkageInfo LI = getLVForDecl(this, LVFlags());
-    assert(LI.visibility() == Visibility(CachedVisibility));
-    assert(LI.visibilityExplicit() == CachedVisibilityIsExplicit);
-    assert(LI.linkage() == Linkage(CachedLinkage));
-#endif
-    return LinkageInfo(Linkage(CachedLinkage), Visibility(CachedVisibility),
-                       CachedVisibilityIsExplicit);
-  }
-  
-  LinkageInfo LI = getLVForDecl(this, LVFlags());
-  HasLinkageAndVisibilityCached = 1;
-  CachedVisibility = LI.visibility();
-  CachedVisibilityIsExplicit = LI.visibilityExplicit();
-  CachedLinkage = LI.linkage();
-  return LI;
-}
-
-void NamedDecl::ClearLinkageAndVisibilityCache() {
-  HasLinkageAndVisibilityCached = 0;
-  
-  if (VarDecl *VD = dyn_cast<VarDecl>(this)) {
-    for (VarDecl::redecl_iterator R = VD->redecls_begin(),
-                               REnd = VD->redecls_end();
-         R != REnd; ++R)
-      R->HasLinkageAndVisibilityCached = 0;
-    
-    return;
-  }
-  
-  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
-    for (FunctionDecl::redecl_iterator R = FD->redecls_begin(),
-                                    REnd = FD->redecls_end();
-         R != REnd; ++R)
-      R->HasLinkageAndVisibilityCached = 0;
-    
-    return;
-  }
-  
-  // Changing the linkage or visibility of a C++ class affect the linkage and
-  // visibility of all of its members. Clear their caches, too.
-  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(this)) {
-    for (DeclContext::decl_iterator D = RD->decls_begin(),
-                                 DEnd = RD->decls_end();
-         D != DEnd; ++D)
-      if (NamedDecl *ND = dyn_cast<NamedDecl>(*D))
-        ND->ClearLinkageAndVisibilityCache();
-  }
+  return getLVForDecl(this, LVFlags());
 }
 
 static LinkageInfo getLVForDecl(const NamedDecl *D, LVFlags Flags) {
@@ -928,14 +878,6 @@ VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
   return new (C) VarDecl(Var, DC, L, Id, T, TInfo, S, SCAsWritten);
 }
 
-void VarDecl::setStorageClass(StorageClass SC) {
-  assert(isLegalForVariable(SC));
-  if (getStorageClass() != SC)
-    ClearLinkageAndVisibilityCache();
-  
-  SClass = SC;
-}
-
 SourceLocation VarDecl::getInnerLocStart() const {
   SourceLocation Start = getTypeSpecStartLoc();
   if (Start.isInvalid())
@@ -1154,7 +1096,6 @@ void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
       PointOfInstantiation.isValid() &&
       MSI->getPointOfInstantiation().isInvalid())
     MSI->setPointOfInstantiation(PointOfInstantiation);
-  ClearLinkageAndVisibilityCache();
 }
 
 //===----------------------------------------------------------------------===//
@@ -1254,10 +1195,8 @@ Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
 
 void FunctionDecl::setBody(Stmt *B) {
   Body = B;
-  if (B) {
+  if (B)
     EndRangeLoc = B->getLocEnd();
-    ClearLinkageAndVisibilityCache();
-  }
 }
 
 void FunctionDecl::setPure(bool P) {
@@ -1338,14 +1277,6 @@ FunctionDecl *FunctionDecl::getCanonicalDecl() {
   return getFirstDeclaration();
 }
 
-void FunctionDecl::setStorageClass(StorageClass SC) {
-  assert(isLegalForFunction(SC));
-  if (getStorageClass() != SC)
-    ClearLinkageAndVisibilityCache();
-  
-  SClass = SC;
-}
-
 /// \brief Returns a value indicating whether this function
 /// corresponds to a builtin function.
 ///
@@ -1778,7 +1709,6 @@ FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
       MSInfo->setPointOfInstantiation(PointOfInstantiation);
   } else
     assert(false && "Function cannot have a template specialization kind");
-  ClearLinkageAndVisibilityCache();
 }
 
 SourceLocation FunctionDecl::getPointOfInstantiation() const {
@@ -1857,7 +1787,6 @@ void TagDecl::setTypedefForAnonDecl(TypedefDecl *TDD) {
   TypedefDeclOrQualifier = TDD; 
   if (TypeForDecl)
     TypeForDecl->ClearLinkageCache();
-  ClearLinkageAndVisibilityCache();
 }
 
 void TagDecl::startDefinition() {
diff --git a/lib/AST/DeclBase.cpp b/lib/AST/DeclBase.cpp
index 3758ca1065..843e907dea 100644
--- a/lib/AST/DeclBase.cpp
+++ b/lib/AST/DeclBase.cpp
@@ -337,38 +337,6 @@ void Decl::dropAttrs() {
   getASTContext().eraseDeclAttrs(this);
 }
 
-void Decl::addAttr(Attr *A) {
-  if (NamedDecl *ND = dyn_cast<NamedDecl>(this))
-    if (VisibilityAttr *Visibility = dyn_cast<VisibilityAttr>(A)) {
-      bool ClearVisibility = true;
-      if (VarDecl *VD = dyn_cast<VarDecl>(this)) {
-        if (VD->getPreviousDeclaration()) {
-          VisibilityAttr *PrevVisibility 
-            = VD->getPreviousDeclaration()->getAttr<VisibilityAttr>();
-          if  (PrevVisibility &&
-               PrevVisibility->getVisibility() == Visibility->getVisibility())
-            ClearVisibility = false;
-        }
-      } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
-        if (FD->getPreviousDeclaration()) {
-          VisibilityAttr *PrevVisibility 
-            = FD->getPreviousDeclaration()->getAttr<VisibilityAttr>();
-          if  (PrevVisibility &&
-               PrevVisibility->getVisibility() == Visibility->getVisibility())
-            ClearVisibility = false;
-        }
-      }
-      
-      if (ClearVisibility)
-        ND->ClearLinkageAndVisibilityCache();
-    }
-  
-  if (hasAttrs())
-    getAttrs().push_back(A);
-  else
-    setAttrs(AttrVec(1, A));
-}
-
 const AttrVec &Decl::getAttrs() const {
   assert(HasAttrs && "No attrs to get!");
   return getASTContext().getDeclAttrs(this);
diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp
index 58cc50b97a..35c89971ea 100644
--- a/lib/AST/DeclCXX.cpp
+++ b/lib/AST/DeclCXX.cpp
@@ -792,8 +792,6 @@ CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
   }
   
   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
-    if (MSInfo->getTemplateSpecializationKind() != TSK)
-      ClearLinkageAndVisibilityCache();
     MSInfo->setTemplateSpecializationKind(TSK);
     return;
   }
diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp
index 7053f404e4..adbf3bff3c 100644
--- a/lib/Serialization/ASTReaderDecl.cpp
+++ b/lib/Serialization/ASTReaderDecl.cpp
@@ -384,7 +384,7 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
-  FD->SClass = (StorageClass)Record[Idx++];
+  FD->setStorageClass((StorageClass)Record[Idx++]);
   FD->setStorageClassAsWritten((StorageClass)Record[Idx++]);
   FD->setInlineSpecified(Record[Idx++]);
   FD->setVirtualAsWritten(Record[Idx++]);
@@ -651,7 +651,7 @@ void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
   VisitDeclaratorDecl(VD);
   VisitRedeclarable(VD);
-  VD->SClass = (StorageClass)Record[Idx++];
+  VD->setStorageClass((StorageClass)Record[Idx++]);
   VD->setStorageClassAsWritten((StorageClass)Record[Idx++]);
   VD->setThreadSpecified(Record[Idx++]);
   VD->setCXXDirectInitializer(Record[Idx++]);