Eliminate Sema::ObjCProtocols. Instead, we place ObjCProtocolDecls in

their own namespace (IDNS_Protocol) and use the normal name-lookup
routines to find them. Aside from the simplification this provides
(one less DenseMap!), it means that protocols will be lazily
deserialized from PCH files.

Make the code size of the selector table block match the code size of
the type and decl blocks.

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

diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp
index 11302d136ed636c0bb17c00b8fa441148a58160f..985d297be15e1d7c81eaa4b49d28bebcbd404cd9 100644 (file)
--- a/lib/Frontend/PCHWriter.cpp
+++ b/lib/Frontend/PCHWriter.cpp
@@ -1888,7 +1888,7 @@ void PCHWriter::WriteIdentifierTable(Preprocessor &PP) {
 }
 
 void PCHWriter::WriteSelectorTable() {
-  Stream.EnterSubblock(pch::SELECTOR_BLOCK_ID, 3);
+  Stream.EnterSubblock(pch::SELECTOR_BLOCK_ID, 2);
   RecordData Record;
   Record.push_back(pch::SELECTOR_TABLE);
   Record.push_back(SelectorIDs.size());

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 5a53374033d26b201109559d85c45e653cb4f346..8cf2af057796f64a76b9cdd0c9d462bd5816be6b 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -176,11 +176,6 @@ public:
   /// we can check for duplicates and find local method declarations.
   llvm::SmallVector<ObjCCategoryImplDecl*, 8> ObjCCategoryImpls;
   
-  /// ObjCProtocols - Keep track of all protocol declarations declared
-  /// with @protocol keyword, so that we can emit errors on duplicates and
-  /// find the declarations when needed.
-  llvm::DenseMap<IdentifierInfo*, ObjCProtocolDecl*> ObjCProtocols;
-
   /// ObjCInterfaceDecls - Keep track of all class declarations declared
   /// with @interface, so that we can emit errors on duplicates and
   /// find the declarations when needed. 
@@ -769,11 +764,13 @@ public:
     /// namespace alias definition, ignoring non-namespace names (C++
     /// [basic.lookup.udir]p1).
     LookupNamespaceName,
-    // Look up an ordinary name that is going to be redeclared as a
-    // name with linkage. This lookup ignores any declarations that
-    // are outside of the current scope unless they have linkage. See 
-    // C99 6.2.2p4-5 and C++ [basic.link]p6.
-    LookupRedeclarationWithLinkage
+    /// Look up an ordinary name that is going to be redeclared as a
+    /// name with linkage. This lookup ignores any declarations that
+    /// are outside of the current scope unless they have linkage. See 
+    /// C99 6.2.2p4-5 and C++ [basic.link]p6.
+    LookupRedeclarationWithLinkage,
+    /// Look up the name of an Objective-C protocol.
+    LookupProtocolName
   };
 
   /// @brief Represents the results of name lookup.
@@ -1025,6 +1022,7 @@ public:
     case Sema::LookupTagName:
     case Sema::LookupMemberName:
     case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
+    case Sema::LookupProtocolName:
       return D->isInIdentifierNamespace(IDNS);
       
     case Sema::LookupOperatorName:
@@ -1058,6 +1056,8 @@ public:
                                 bool AllowBuiltinCreation = true,
                                 SourceLocation Loc = SourceLocation());
 
+  ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
+
   void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
                                     QualType T1, QualType T2, 
                                     FunctionSet &Functions);

diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp
index 6702eb9a7a23e2d4ce505df82b11393ab7aa530d..7badaa313049f9c1d37944f2c37e0a714806bc29 100644 (file)
--- a/lib/Sema/SemaDeclObjC.cpp
+++ b/lib/Sema/SemaDeclObjC.cpp
@@ -222,7 +222,7 @@ void Sema::CheckForwardProtocolDeclarationForCircularDependency(
   for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
        E = PList.end(); I != E; ++I) {
        
-    if (ObjCProtocolDecl *PDecl = ObjCProtocols[(*I)->getIdentifier()]) {
+    if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier())) {
       if (PDecl->getIdentifier() == PName) {
         Diag(Ploc, diag::err_protocol_has_circular_dependency);
         Diag(PrevLoc, diag::note_previous_definition);
@@ -243,7 +243,7 @@ Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
                                   AttributeList *AttrList) {
   // FIXME: Deal with AttrList.
   assert(ProtocolName && "Missing protocol identifier");
-  ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName];
+  ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolName);
   if (PDecl) {
     // Protocol already seen. Better be a forward protocol declaration
     if (!PDecl->isForwardDecl()) {
@@ -265,10 +265,8 @@ Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
   } else {
     PDecl = ObjCProtocolDecl::Create(Context, CurContext, 
                                      AtProtoInterfaceLoc,ProtocolName);
-    // FIXME: PushOnScopeChains?
-    CurContext->addDecl(Context, PDecl);
+    PushOnScopeChains(PDecl, TUScope);
     PDecl->setForwardDecl(false);
-    ObjCProtocols[ProtocolName] = PDecl;
   }
   if (AttrList)
     ProcessDeclAttributeList(PDecl, AttrList);
@@ -291,7 +289,7 @@ Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
                               unsigned NumProtocols,
                               llvm::SmallVectorImpl<DeclPtrTy> &Protocols) {
   for (unsigned i = 0; i != NumProtocols; ++i) {
-    ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i].first];
+    ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolId[i].first);
     if (!PDecl) {
       Diag(ProtocolId[i].second, diag::err_undeclared_protocol)
         << ProtocolId[i].first;
@@ -514,12 +512,11 @@ Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
   
   for (unsigned i = 0; i != NumElts; ++i) {
     IdentifierInfo *Ident = IdentList[i].first;
-    ObjCProtocolDecl *&PDecl = ObjCProtocols[Ident];
+    ObjCProtocolDecl *PDecl = LookupProtocol(Ident);
     if (PDecl == 0) { // Not already seen?
       PDecl = ObjCProtocolDecl::Create(Context, CurContext, 
                                        IdentList[i].second, Ident);
-      // FIXME: PushOnScopeChains?
-      CurContext->addDecl(Context, PDecl);
+      PushOnScopeChains(PDecl, TUScope);
     }
     if (attrList)
       ProcessDeclAttributeList(PDecl, attrList);

diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp
index 23f6f94dc06399c647bdf86640e8d97951b5c2b0..1df7f3dcc913509319b1422da5d0e59ad0c37a2e 100644 (file)
--- a/lib/Sema/SemaExprObjC.cpp
+++ b/lib/Sema/SemaExprObjC.cpp
@@ -128,7 +128,7 @@ Sema::ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
                                                    SourceLocation ProtoLoc,
                                                    SourceLocation LParenLoc,
                                                    SourceLocation RParenLoc) {
-  ObjCProtocolDecl* PDecl = ObjCProtocols[ProtocolId];
+  ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId);
   if (!PDecl) {
     Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
     return true;

diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 0b11d9cf68c9835042094221fd25420c141c7e76..613c30bc0cb7af1418492b65f82b68f0de84fb90 100644 (file)
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -293,6 +293,10 @@ getIdentifierNamespacesFromLookupNameKind(Sema::LookupNameKind NameKind,
   case Sema::LookupNamespaceName:
     IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member;
     break;
+
+  case Sema::LookupProtocolName:
+    IDNS = Decl::IDNS_Protocol;
+    break;
   }
   return IDNS;
 }
@@ -831,6 +835,10 @@ Sema::LookupName(Scope *S, DeclarationName Name, LookupNameKind NameKind,
         S = S->getParent();
       IDNS = Decl::IDNS_Ordinary;
       break;
+
+    case Sema::LookupProtocolName:
+      IDNS = Decl::IDNS_Protocol;
+      break;
     }
 
     // Scan up the scope chain looking for a decl that matches this
@@ -1480,6 +1488,12 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn,
   return false;
 }
 
+/// \brief Find the protocol with the given name, if any.
+ObjCProtocolDecl *Sema::LookupProtocol(IdentifierInfo *II) {
+  Decl *D = LookupName(TUScope, II, LookupProtocolName).getAsDecl();
+  return cast_or_null<ObjCProtocolDecl>(D);
+}
+
 void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
                                         QualType T1, QualType T2, 
                                         FunctionSet &Functions) {