diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index 9540804..fca141a 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -99,10 +99,25 @@
   /// constructor, Objective-C selector, etc.)
   DeclarationName Name;
 
+  /// \brief Whether we have already cached linkage and visibility.
+  mutable unsigned HasLinkageAndVisibilityCached : 1;
+
+  /// \brief The cached visibility, if \c HasLinkageAndVisibilityCached is 
+  /// non-zero.
+  mutable unsigned CachedVisibility : 2;
+
+  /// \brief Whether the cached visibility was explicitly placed on this
+  /// declaration.
+  mutable unsigned CachedVisibilityIsExplicit : 1;
+  
+  /// \brief The cached linkage, if \c HasLinkageAndVisibilityCached is
+  /// non-zero.
+  mutable unsigned CachedLinkage : 2;
+
 protected:
   NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
-    : Decl(DK, DC, L), Name(N) { }
-
+    : Decl(DK, DC, L), Name(N), HasLinkageAndVisibilityCached(0) { }
+  
 public:
   /// getIdentifier - Get the identifier that names this declaration,
   /// if there is one. This will return NULL if this declaration has
@@ -272,6 +287,13 @@
   /// \brief Determines the linkage and visibility of this entity.
   LinkageInfo getLinkageAndVisibility() const;
 
+  /// \brief Clear the linkage and visibility cache in response to a change
+  /// to the declaration. 
+  ///
+  /// \param Redeclarations When true, we also have to clear out the linkage
+  /// and visibility cache for all redeclarations.
+  void ClearLinkageAndVisibilityCache();
+
   /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for
   /// the underlying named decl.
   NamedDecl *getUnderlyingDecl();
@@ -625,6 +647,8 @@
   bool NRVOVariable : 1;
   
   friend class StmtIteratorBase;
+  friend class ASTDeclReader;
+  
 protected:
   VarDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
           QualType T, TypeSourceInfo *TInfo, StorageClass SC,
@@ -660,10 +684,7 @@
   StorageClass getStorageClassAsWritten() const {
     return (StorageClass) SClassAsWritten;
   }
-  void setStorageClass(StorageClass SC) {
-    assert(isLegalForVariable(SC));
-    SClass = SC;
-  }
+  void setStorageClass(StorageClass SC);
   void setStorageClassAsWritten(StorageClass SC) {
     assert(isLegalForVariable(SC));
     SClassAsWritten = SC;
@@ -1478,10 +1499,7 @@
   }
                        
   StorageClass getStorageClass() const { return StorageClass(SClass); }
-  void setStorageClass(StorageClass SC) {
-    assert(isLegalForFunction(SC));
-    SClass = SC;
-  }
+  void setStorageClass(StorageClass SC);
 
   StorageClass getStorageClassAsWritten() const {
     return StorageClass(SClassAsWritten);
@@ -2545,6 +2563,63 @@
   return DB;
 }
 
+template<typename decl_type>
+void Redeclarable<decl_type>::setPreviousDeclaration(decl_type *PrevDecl) {
+  // Note: This routine is implemented here because we need both NamedDecl
+  // and Redeclarable to be defined.
+  decl_type *First;
+  
+  if (PrevDecl) {
+    // Point to previous. Make sure that this is actually the most recent
+    // redeclaration, or we can build invalid chains. If the most recent
+    // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
+    RedeclLink = PreviousDeclLink(llvm::cast<decl_type>(
+                                                        PrevDecl->getMostRecentDeclaration()));
+    First = PrevDecl->getFirstDeclaration();
+    assert(First->RedeclLink.NextIsLatest() && "Expected first");
+  } else {
+    // Make this first.
+    First = static_cast<decl_type*>(this);
+  }
+  
+  // First one will point to this one as latest.
+  First->RedeclLink = LatestDeclLink(static_cast<decl_type*>(this));
+  
+  // If this declaration has a visibility attribute that differs from the 
+  // previous visibility attribute, or has private extern storage while the
+  // previous declaration merely had extern storage, clear out the linkage and 
+  ///visibility cache. This is required because declarations after the first 
+  // declaration can change the visibility for all previous and future 
+  // declarations.
+  if (NamedDecl *ND = dyn_cast<NamedDecl>(static_cast<decl_type*>(this))) {
+    bool MustClear = false;
+    if (VisibilityAttr *Visibility = ND->getAttr<VisibilityAttr>()) {
+      VisibilityAttr *PrevVisibility 
+                                = PrevDecl->template getAttr<VisibilityAttr>();
+      if (!PrevVisibility || 
+          PrevVisibility->getVisibility() != Visibility->getVisibility())
+        MustClear = true;
+    }
+    
+    if (!MustClear) {
+      if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
+        if (VD->getStorageClass() != cast<VarDecl>(PrevDecl)->getStorageClass())
+          MustClear = true;
+      } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
+        FunctionDecl *PrevFD = cast<FunctionDecl>(PrevDecl);
+        if (FD->getStorageClass() != PrevFD->getStorageClass())
+          MustClear = true;
+        else if (FD->isInlineSpecified() && !PrevFD->isInlined())
+          MustClear = true;
+      }
+    }
+    
+    if (MustClear)
+      ND->ClearLinkageAndVisibilityCache();
+  }
+}
+
+
 }  // end namespace clang
 
 #endif
diff --git a/clang/include/clang/AST/DeclBase.h b/clang/include/clang/AST/DeclBase.h
index 0aa60ce..699950e 100644
--- a/clang/include/clang/AST/DeclBase.h
+++ b/clang/include/clang/AST/DeclBase.h
@@ -198,7 +198,7 @@
     return DeclCtx.get<DeclContext*>();
   }
 
-  /// Loc - The location that this decl.
+  /// Loc - The location of this decl.
   SourceLocation Loc;
 
   /// DeclKind - This indicates which class this is.
@@ -316,12 +316,7 @@
   void swapAttrs(Decl *D);
   void dropAttrs();
 
-  void addAttr(Attr *A) {
-    if (hasAttrs())
-      getAttrs().push_back(A);
-    else
-      setAttrs(AttrVec(1, A));
-  }
+  void addAttr(Attr *A);
 
   typedef AttrVec::const_iterator attr_iterator;
 
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index bde2e24..9d74320 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -1241,6 +1241,8 @@
   }
 
   void setSpecializationKind(TemplateSpecializationKind TSK) {
+    if (SpecializationKind != TSK)
+      ClearLinkageAndVisibilityCache();
     SpecializationKind = TSK;
   }
 
diff --git a/clang/include/clang/AST/Redeclarable.h b/clang/include/clang/AST/Redeclarable.h
index ba77829..4a1c1d0 100644
--- a/clang/include/clang/AST/Redeclarable.h
+++ b/clang/include/clang/AST/Redeclarable.h
@@ -109,26 +109,8 @@
   
   /// \brief Set the previous declaration. If PrevDecl is NULL, set this as the
   /// first and only declaration.
-  void setPreviousDeclaration(decl_type *PrevDecl) {
-    decl_type *First;
-
-    if (PrevDecl) {
-      // Point to previous. Make sure that this is actually the most recent
-      // redeclaration, or we can build invalid chains. If the most recent
-      // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
-      RedeclLink = PreviousDeclLink(llvm::cast<decl_type>(
-                                      PrevDecl->getMostRecentDeclaration()));
-      First = PrevDecl->getFirstDeclaration();
-      assert(First->RedeclLink.NextIsLatest() && "Expected first");
-    } else {
-      // Make this first.
-      First = static_cast<decl_type*>(this);
-    }
-
-    // First one will point to this one as latest.
-    First->RedeclLink = LatestDeclLink(static_cast<decl_type*>(this));
-  }
-
+  void setPreviousDeclaration(decl_type *PrevDecl);
+  
   /// \brief Iterates through all the redeclarations of the same decl.
   class redecl_iterator {
     /// Current - The current declaration.
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index 9664fe2..19fbf69 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -526,7 +526,57 @@
 }
 
 LinkageInfo NamedDecl::getLinkageAndVisibility() const {
-  return getLVForDecl(this, LVFlags());
+  // 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() == CachedVisibility);
+    assert(LI.visibilityExplicit() == CachedVisibilityIsExplicit);
+    assert(LI.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();
+  }
 }
 
 static LinkageInfo getLVForDecl(const NamedDecl *D, LVFlags Flags) {
@@ -878,6 +928,14 @@
   return new (C) VarDecl(Var, DC, L, Id, T, TInfo, S, SCAsWritten);
 }
 
+void VarDecl::setStorageClass(StorageClass SC) {
+  assert(isLegalForVariable(SC));
+  if (SClass != SC)
+    ClearLinkageAndVisibilityCache();
+  
+  SClass = SC;
+}
+
 SourceLocation VarDecl::getInnerLocStart() const {
   SourceLocation Start = getTypeSpecStartLoc();
   if (Start.isInvalid())
@@ -1096,6 +1154,7 @@
       PointOfInstantiation.isValid() &&
       MSI->getPointOfInstantiation().isInvalid())
     MSI->setPointOfInstantiation(PointOfInstantiation);
+  ClearLinkageAndVisibilityCache();
 }
 
 //===----------------------------------------------------------------------===//
@@ -1196,8 +1255,10 @@
 
 void FunctionDecl::setBody(Stmt *B) {
   Body = B;
-  if (B)
+  if (B) {
     EndRangeLoc = B->getLocEnd();
+    ClearLinkageAndVisibilityCache();
+  }
 }
 
 void FunctionDecl::setPure(bool P) {
@@ -1278,6 +1339,14 @@
   return getFirstDeclaration();
 }
 
+void FunctionDecl::setStorageClass(StorageClass SC) {
+  assert(isLegalForFunction(SC));
+  if (SClass != SC)
+    ClearLinkageAndVisibilityCache();
+  
+  SClass = SC;
+}
+
 /// \brief Returns a value indicating whether this function
 /// corresponds to a builtin function.
 ///
@@ -1710,6 +1779,7 @@
       MSInfo->setPointOfInstantiation(PointOfInstantiation);
   } else
     assert(false && "Function cannot have a template specialization kind");
+  ClearLinkageAndVisibilityCache();
 }
 
 SourceLocation FunctionDecl::getPointOfInstantiation() const {
@@ -1788,6 +1858,7 @@
   TypedefDeclOrQualifier = TDD; 
   if (TypeForDecl)
     TypeForDecl->ClearLinkageCache();
+  ClearLinkageAndVisibilityCache();
 }
 
 void TagDecl::startDefinition() {
diff --git a/clang/lib/AST/DeclBase.cpp b/clang/lib/AST/DeclBase.cpp
index 843e907..3758ca1 100644
--- a/clang/lib/AST/DeclBase.cpp
+++ b/clang/lib/AST/DeclBase.cpp
@@ -337,6 +337,38 @@
   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/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp
index 547a70a..9e9b5ab 100644
--- a/clang/lib/AST/DeclCXX.cpp
+++ b/clang/lib/AST/DeclCXX.cpp
@@ -792,6 +792,8 @@
   }
   
   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
+    if (MSInfo->getTemplateSpecializationKind() != TSK)
+      ClearLinkageAndVisibilityCache();
     MSInfo->setTemplateSpecializationKind(TSK);
     return;
   }
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index b1e46a6..c21dfc2 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -383,7 +383,7 @@
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
-  FD->setStorageClass((StorageClass)Record[Idx++]);
+  FD->SClass = (StorageClass)Record[Idx++];
   FD->setStorageClassAsWritten((StorageClass)Record[Idx++]);
   FD->setInlineSpecified(Record[Idx++]);
   FD->setVirtualAsWritten(Record[Idx++]);
@@ -650,7 +650,7 @@
 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
   VisitDeclaratorDecl(VD);
   VisitRedeclarable(VD);
-  VD->setStorageClass((StorageClass)Record[Idx++]);
+  VD->SClass = (StorageClass)Record[Idx++];
   VD->setStorageClassAsWritten((StorageClass)Record[Idx++]);
   VD->setThreadSpecified(Record[Idx++]);
   VD->setCXXDirectInitializer(Record[Idx++]);