RFC: Implement objc_direct_protocol attribute to remove protocol metadata

[lanza]

Summary

Motivated by the new objc_direct attribute, this change aims to limit
metadata generation from Protocols that the programmer knows isn't
going to be used at runtime. This attribute simply causes the frontend
to not generate any protocol metadata entries (e.g. OBJC_CLASS_NAME,
_OBJC_$_PROTOCOL_INSTANCE_METHDOS, _OBJC_PROTOCOL, etc) for a protocol
marked with __attribute__((objc_direct)).

There are a few APIs used to retrieve a protocol at runtime.
@protocol(SomeProtocol) will now error out of the requested protocol
is marked with attribute. objc_getProtocol will returl NULL which
is consistent with the behavior of a non-existing protocol.

[aaron.ballman]

Adding some more knowledgeable reviewers for comments on your RFC. I pointed out a few minor nits, but I'll hold off on a technical review until the ObjC-specific details are worked out and there is buy-in on the feature.

clang/include/clang/AST/DeclObjC.h

2181

Comments should be properly punctuated (missing a full stop at the end of the sentence), here and elsewhere.

clang/lib/Sema/SemaDeclAttr.cpp

2622

This should be implemented via a custom LangOpt in Attr.td

[rjmccall]

I'm fine with people developing a proposal for this openly, but it needs to be said that language changes cannot just be made in open-source; they have to go through the official language review process, which for Objective-C is an internal committee within Apple.

The summary calls this objc_direct_protocol, but it's objc_static_protocol in the patch. I agree that "direct" isn't a great name for this. static is complicated, because while we use "static" vs. "dynamic" this way when we're talking *about* languages, I'm not sure any of the umpteen language uses of static ever use it in exactly this way, and it's possibly quite confusing to add one. Throwing out other names here: objc_non_runtime_protocol? objc_compiler_only_protocol?

The technical content of the patch seems fine.

[lanza]

Adding some more knowledgeable reviewers for comments on your RFC. I pointed out a few minor nits, but I'll hold off on a technical review until the ObjC-specific details are worked out and there is buy-in on the feature.

Thanks!

This should be implemented via a custom LangOpt in Attr.td

This was done to more-or-less mirror the behavior from objc_direct. Though if people think the implementations should differ I'm cool with that.

In D75574#1911368, @rjmccall wrote:

I'm fine with people developing a proposal for this openly, but it needs to be said that language changes cannot just be made in open-source; they have to go through the official language review process, which for Objective-C is an internal committee within Apple.

Yea sure, whatever the correct process is I'm more than happy to cooperate. I was going to post something on the mailing list some time this week, but this diff got attention early! What would be the best way to start that conversation?

The summary calls this objc_direct_protocol, but it's objc_static_protocol in the patch. I agree that "direct" isn't a great name for this. static is complicated, because while we use "static" vs. "dynamic" this way when we're talking *about* languages, I'm not sure any of the umpteen language uses of static ever use it in exactly this way, and it's possibly quite confusing to add one. Throwing out other names here: objc_non_runtime_protocol? objc_compiler_only_protocol?

Yea, the naming I'm not too happy about and changed it around a few times. Your proposed naming is certainly more clear.

The technical content of the patch seems fine.

👍

clang/include/clang/AST/DeclObjC.h

2181

👍

[rjmccall]

This might also be interesting to @manmanren.

[manmanren]

In D75574#1925808, @rjmccall wrote:

This might also be interesting to @manmanren.

Thank you, John!

Manman

[lanza]

Rename and address some issues

[lanza]

Reword commit

[rjmccall]

If someone writes up a short proposal for this, with motivation and impact, we'd be happy to present it internally.

[lanza]

If someone writes up a short proposal for this, with motivation and impact, we'd be happy to present it internally.

I have a rough draft that I'll be touching up and submitting Monday most likely! Thanks, John!

[lanza]

@rjmccall Hey John, I sent the proposal to the addresses I was pointed to but haven't heard back in multiple weeks. Any update on this?

[rjmccall]

Sorry, I should've been more straight with you. I'm still happy to raise this internally, but this is a hectic time of the year at Apple, and I'm not actually going to raise it until after WWDC. It wouldn't be making it into the new Xcode release anyway.

[lanza]

ping @rjmccall. Any update on a timeline for this review process? Thanks!

[rjmccall]

Sorry, this slipped out of my mind. I've started the process internally.

[lanza]

No problem! Thank you, John!

[rjmccall]

One thing that's come up so far: you generally need to be looking through non-runtime protocols, not ignoring them. This matters when non-runtime protocols inherit from ordinary protocols. It may be useful to provide a generic function that walks an array of protocols and calls a callback with the unique ordinary protocols it implies.

You should also implement this for non-Apple runtimes, which should be straightforward with that generic function; it's just a matter of testing it. CC'ing David Chisnall.

[theraven]

This feature looks generally useful. A few small suggestions:

• This is really a way of transforming a formal protocol into an informal protocol. Objective-C has had a convention of informal protocols since the '80s, but they're implemented as categories on the root class with no @implementation. I'd suggest that __attribute__((objc_informal_protocol)) or similar might be a better spelling for this, explicitly bringing the informal notion into the language. A lot of the informal protocols in Cocoa could be better expressed using this and @optional methods than as categories on NSObject.
• Given that this doesn't depend on any features in the runtime (from the runtime's perspective, the protocol doesn't exist), I don't think it makes sense to have an ObjCRuntime method to query whether this is supported by the runtime. We should enable it everywhere if it's going in anywhere.
• The changes required in CGObjcCGNU.cpp are fairly small and I agree that @rjmccall's proposal for a callback-driven visitor would simplify the changes in both runtimes.
• The semantics are slightly confusing with the deep approach though. Normally, if you iterate over the protocols that a class conforms to, you only see the ones that it directly conforms to. With this model, you'd see indirect ones. We might want to set some metadata to allow programmers to differentiate the two, or we might want to have a warning (off by default?) if an informal protocol conforms to a formal one, or simply disallow it.

[rjmccall]

In D75574#2202136, @theraven wrote:

This feature looks generally useful. A few small suggestions:

• This is really a way of transforming a formal protocol into an informal protocol. Objective-C has had a convention of informal protocols since the '80s, but they're implemented as categories on the root class with no @implementation. I'd suggest that __attribute__((objc_informal_protocol)) or similar might be a better spelling for this, explicitly bringing the informal notion into the language. A lot of the informal protocols in Cocoa could be better expressed using this and @optional methods than as categories on NSObject.

It's still a formal protocol, it just doesn't have runtime representation. I think the name is appropriate. It's an interesting point that some of the informal protocols could be formalized without penalty using this, though.

• Given that this doesn't depend on any features in the runtime (from the runtime's perspective, the protocol doesn't exist), I don't think it makes sense to have an ObjCRuntime method to query whether this is supported by the runtime. We should enable it everywhere if it's going in anywhere.

Agreed.

• The changes required in CGObjcCGNU.cpp are fairly small and I agree that @rjmccall's proposal for a callback-driven visitor would simplify the changes in both runtimes.
• The semantics are slightly confusing with the deep approach though. Normally, if you iterate over the protocols that a class conforms to, you only see the ones that it directly conforms to. With this model, you'd see indirect ones. We might want to set some metadata to allow programmers to differentiate the two, or we might want to have a warning (off by default?) if an informal protocol conforms to a formal one, or simply disallow it.

I don't see why this information would be useful.

[lanza]

A concern that has come up while rewriting this for the listed concerns is forward declared protocols that are defined as non_runtime.

@protocol NonRuntimeProto;

@interface Implementer : Root <NonRuntimeProto>
@end

@implementation Implementer
@end

This compiles just fine but with a warning in clang 12. It'll emit a reference to the NonRuntimeProto without ever having had the chance to see the objc_non_runtime_protocol defined elsewhere and will thus error out at link.

There's a few ways to move forward with this:

1. Ignore it. If the user decided that a protocol was objc_non_runtime_protocol they probably have the insight necessary to address this link error. This is no more difficult than many C++ linker errors to diagnose.
2. Make it an error if the protocol is not defined prior to the implementation but leave forward-decls as valid for interfaces.

[rjmccall]

I don't think it'll actually error out at link time: protocol objects get emitted eagerly on use, cross-module linking is just a code-size optimization. This actually has caused longstanding problems.

Anyway, I think it's fine to require forward declarations to have the attribute.

[lanza]

I don't think it'll actually error out at link time: protocol objects get emitted eagerly on use, cross-module linking is just a code-size optimization. This actually has caused longstanding problems.

But if it's just a forward declaration there's nothing to emit. The above code compiles just fine as is with just a warning. Here's the result of clang protocol.m -lobjc

proto.m:10:31: warning: cannot find protocol definition for 'NonRuntimeProto'
@interface Implementer : Root<NonRuntimeProto>
                              ^
proto.m:8:11: note: protocol 'NonRuntimeProto' has no definition
@protocol NonRuntimeProto;
          ^
1 warning generated.
Undefined symbols for architecture x86_64:
  "__OBJC_PROTOCOL_$_NonRuntimeProto", referenced from:
      __OBJC_CLASS_PROTOCOLS_$_Implementer in proto-bd4a43.o
ld: symbol(s) not found for architecture x86_64
clang-12: error: linker command failed with exit code 1 (use -v to see invocation)

The protocol definition isn't actually required to compile an implementation. And if that protocol is declared as objc_non_runtime_protocol it won't ever see one.

Simply requiring that it is annotated accordingly also isn't satisfactory for the same inheritance problem you mentioned above. Annotating a forward decl can tell clang not to emit it but won't let clang know if there's a base protocol that still needs to be emitted. e.g. if we have

// SomeHeader.h
@protocol Base
@end
__attribute__((objc_non_runtime_protocol))
@protocol NonRuntime <Base>
@end


// and in main.m
__attribute__((objc_non_runtime_protocol))
@protocol NonRuntime
@interface AClass : Root<NonRunime>
@end
@implementation AClass
@end

we'll get a compile warning but no link error. But it will be wrong as the protocol Base should still be in the protocollist for AClass.

I'm not sure how big of an issue it would be introducing a new error here for code that used to compile, but that's really the only way I see this working.

[rjmccall]

In D75574#2262622, @lanza wrote:

I don't think it'll actually error out at link time: protocol objects get emitted eagerly on use, cross-module linking is just a code-size optimization. This actually has caused longstanding problems.

But if it's just a forward declaration there's nothing to emit. The above code compiles just fine as is with just a warning. Here's the result of clang protocol.m -lobjc

proto.m:10:31: warning: cannot find protocol definition for 'NonRuntimeProto'
@interface Implementer : Root<NonRuntimeProto>
                              ^
proto.m:8:11: note: protocol 'NonRuntimeProto' has no definition
@protocol NonRuntimeProto;
          ^
1 warning generated.
Undefined symbols for architecture x86_64:
  "__OBJC_PROTOCOL_$_NonRuntimeProto", referenced from:
      __OBJC_CLASS_PROTOCOLS_$_Implementer in proto-bd4a43.o
ld: symbol(s) not found for architecture x86_64
clang-12: error: linker command failed with exit code 1 (use -v to see invocation)

The protocol definition isn't actually required to compile an implementation. And if that protocol is declared as objc_non_runtime_protocol it won't ever see one.

Simply requiring that it is annotated accordingly also isn't satisfactory for the same inheritance problem you mentioned above. Annotating a forward decl can tell clang not to emit it but won't let clang know if there's a base protocol that still needs to be emitted. e.g. if we have

// SomeHeader.h
@protocol Base
@end
__attribute__((objc_non_runtime_protocol))
@protocol NonRuntime <Base>
@end


// and in main.m
__attribute__((objc_non_runtime_protocol))
@protocol NonRuntime
@interface AClass : Root<NonRunime>
@end
@implementation AClass
@end

we'll get a compile warning but no link error. But it will be wrong as the protocol Base should still be in the protocollist for AClass.

I'm not sure how big of an issue it would be introducing a new error here for code that used to compile, but that's really the only way I see this working.

Hmm, I thought we actually just generated a bogus definition for the protocol when it was forward-declared; really, this is better behavior that I expected. Regardless, I don't think it's worthwhile to diagnose this more strongly than a warning because of the history of not doing so.

Not really important for this PR anyway. Was your question answered well enough to move forward?

[lanza]

Hmm, I thought we actually just generated a bogus definition for the protocol when it was forward-declared; really, this is better behavior that I expected. Regardless, I don't think it's worthwhile to diagnose this more strongly than a warning because of the history of not doing so.

That's fair!

Not really important for this PR anyway. Was your question answered well enough to move forward?

Yea sure, I'm okay with leaving it as a warning and moving forward and fixing your suggestions. I just wanted to make sure to cover any possible concerns.

[lanza]

Update

[lanza]

@theraven @rjmccall should be ready for review whenever you guys are ready!

[theraven]

Looks good to me, thank you!

[rjmccall]

Okay, the result of internal review is that we're comfortable with this feature.

Reviewers brought up the point that it would be interesting to add some way to ensure unique emission of a protocol, so that protocols that can't be non-runtime could avoid bloating binary sizes outside the defining module. Maybe this could be deployment-gated so that builds targeting iOS 21 can take advantage of NSMoveOnlyType being exported but builds targeting iOS 20 still have to emit their own copy. But that's a separable improvement and doesn't need to block this work.

clang/include/clang/Basic/AttrDocs.td

4634

Suggestion:

The ``objc_non_runtime_protocol`` attribute can be used to mark that an
Objective-C protocol is only used during static type-checking and doesn't
need to be represented dynamically.  This avoids several small code-size
and run-time overheads associated with handling the protocol's metadata.
A non-runtime protocol cannot be used as the operand of a ``@protocol``
expression, and dynamic attempts to find it with ``objc_getProtocol`` will fail.

If a non-runtime protocol inherits from any ordinary protocols, classes and
derived protocols that declare conformance to the non-runtime protocol
will dynamically list their conformance to those base protocols.

clang/include/clang/Basic/DiagnosticSemaKinds.td

1062

This is dead now.

clang/lib/CodeGen/CGObjC.cpp

466

Should this make an effort to avoid declaring redundant bases? e.g.

@protocol Base @end
@protocol NonRuntime<Base> @end
@protocol Runtime<Base> @end
@interface MyClass <Runtime, NonRuntime> @end
@implementation MyClass @end

Ideally MyClass only declares conformance to Runtime rather than redundantly declaring conformance to Base, which I think you'd naturally get from this algorithm.

[lanza]

Fix duplicate inheritance issue

[lanza]

Fixed and added a test under the REDUNDANCY prefix.

[lanza]

clang/lib/CodeGen/CGObjC.cpp

466

You are right. I fixed this but excluded the case where the declaration explicitly lists in it's <> declaration that it does inherit from a protocol. e.g. In the test case:

@protocol C @endp
@protocol B <C> @end
@protocol A <B> @end
__attribute__((objc_non_runtime_protocol)) @protocol Alpha<A> @end
__attribute__((objc_non_runtime_protocol)) @protocol Beta<B> @end
@interface Implementer : Root <Alpha, Beta, C> @end
@implementation Implementer @end

The non-runtime removing algorithm generates A,B,C as the list but B and C are both redundant. It makes sense to remove B for that reason but since the declaration explicitly mentions C I vote that it makes sense to leave it included as that's what one would expect from a class_copyProtocolList.

[rjmccall]

clang/lib/CodeGen/CGObjC.cpp

490

You should use llvm::DenseSet for this. But in general there are more sets here than I think you really need, and you're building them eagerly when you don't have to. I would suggest:

1. Walk the list of declared protocols, adding the runtime protocols to the main result list and the first runtime protocols implied by the non-runtime protocols to a different list.

2. If there are any protocols in the first-implied list (which is unlikely), build the implied-protocols set for all the protocols in the main list (inclusive of the protocols there) and the first-implied list (exclusive). It would be totally reasonable to add a method to make this easier: void ObjCProtocolDecl::getImpliedProtocols(llvm::DenseSet<const ObjCProtocolDecl*> &) const;

3. Add any protocols that are in the first-implied list but not the implied set back to the main list.

Also, protocols can be redeclared, so you should make sure to map to the canonical decl before adding them to a set (or UniqueVector).

[lanza]

Update with John's suggestions

[lanza]

clang/lib/CodeGen/CGObjC.cpp

490

Got ya, that should be much better for the 99.99% case where there are no non-runtime protocols. 👍

[rjmccall]

Thanks, that's a lot better. Just some minor suggestions.

clang/lib/CodeGen/CGObjC.cpp

477

empty(), please

487

You should add something like ", including all the runtime protocols but not the non-runtime protocols".

499

Comment on this pass.

501

PD is already canonical here (and if it weren't, looking in AllImpliedProtocols wouldn't work).

[lanza]

clang/lib/CodeGen/CGObjC.cpp

487

Do you anticipate a usage of getImpliedProtocols other than this algorithm? I include the non-runtime protos in the all implied list simply because it simplifies the collection. e.g. you insert iff it's a runtime protocol and if not you have to check contains and then potentially add a non-runtime to the work queue as many times as it's seen.

Ultimately their inclusion in the all-implied list is meaningless because we never attempt to insert a non-runtime protocol into the RuntimePDs list anyways. So it's either extra elements in the AllImplied list or extra work in the getImpliedProtocols method without any behavioral differences.

[lanza]

Comments

[rjmccall]

clang/lib/CodeGen/CGObjC.cpp

487

Ah, yes, that's a fair point.

[lanza]

Clean clang-tidy warnings before landing

[kastiglione]

clang/include/clang/AST/DeclObjC.h

2181

This comment refers to the original spelling.

[lanza]

clang/include/clang/AST/DeclObjC.h

2181

Yes indeed, I'll push a comment fix commit.

clang/include/clang/AST/DeclObjC.h

public:
   /// setProtocolList - Set the list of protocols that this interface
   /// implements.
   void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
                        const SourceLocation *Locs, ASTContext &C) {
     assert(hasDefinition() && "Protocol is not defined");
     data().ReferencedProtocols.set(List, Num, Locs, C);
   }
 
+  /// This is true iff the protocol is tagged with the `objc_static_protocol`
+  /// attribute.
+  bool isNonRuntimeProtocol() const;
+
+  /// Get the set of all protocols implied by this protocols inheritance
+  /// hierarchy.
+  void getImpliedProtocols(llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const;
+
   ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName);
 
   // Lookup a method. First, we search locally. If a method isn't
   // found, we search referenced protocols and class categories.
   ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const;
 
   ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
     return lookupMethod(Sel, true/*isInstance*/);

clang/include/clang/Basic/Attr.td

 
 def ObjCDirectMembers : Attr {
   let Spellings = [Clang<"objc_direct_members">];
   let Subjects = SubjectList<[ObjCImpl, ObjCInterface, ObjCCategory], ErrorDiag>;
   let LangOpts = [ObjC];
   let Documentation = [ObjCDirectMembersDocs];
 }
 
+def ObjCNonRuntimeProtocol : Attr {
+  let Spellings = [Clang<"objc_non_runtime_protocol">];
+  let Subjects = SubjectList<[ObjCProtocol], ErrorDiag>;
+  let LangOpts = [ObjC];
+  let Documentation = [ObjCNonRuntimeProtocolDocs];
+}
+
 def ObjCRuntimeName : Attr {
   let Spellings = [Clang<"objc_runtime_name">];
   let Subjects = SubjectList<[ObjCInterface, ObjCProtocol], ErrorDiag>;
   let Args = [StringArgument<"MetadataName">];
   let Documentation = [ObjCRuntimeNameDocs];
 }
 
 def ObjCRuntimeVisible : Attr {

clang/include/clang/Basic/AttrDocs.td

 When ``objc_direct_members`` is placed on an ``@implementation`` block,
 methods defined in the block are considered to be declared as direct unless
 they have been previously declared as non-direct in any interface of the class.
 This includes the implicit method definitions introduced by synthesized
 properties, including auto-synthesized properties.
   }];
 }
 
+def ObjCNonRuntimeProtocolDocs : Documentation {
+  let Category = DocCatDecl;
+  let Content = [{
+The ``objc_non_runtime_protocol`` attribute can be used to mark that an
+Objective-C protocol is only used during static type-checking and doesn't need
+to be represented dynamically. This avoids several small code-size and run-time
+overheads associated with handling the protocol's metadata. A non-runtime
+protocol cannot be used as the operand of a ``@protocol`` expression, and
+dynamic attempts to find it with ``objc_getProtocol`` will fail.
+
+If a non-runtime protocol inherits from any ordinary protocols, classes and
+derived protocols that declare conformance to the non-runtime protocol will
+dynamically list their conformance to those bare protocols.
+  }];
+}
+
 def SelectAnyDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{
 This attribute appertains to a global symbol, causing it to have a weak
 definition (
 `linkonce <https://llvm.org/docs/LangRef.html#linkage-types>`_
 ), allowing the linker to select any definition.
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_inconsistent_ivar_count : Error<
   "inconsistent number of instance variables specified">;
 def warn_undef_method_impl : Warning<"method definition for %0 not found">,
   InGroup<DiagGroup<"incomplete-implementation">>;
 def warn_objc_boxing_invalid_utf8_string : Warning<
   "string is ill-formed as UTF-8 and will become a null %0 when boxed">,
   InGroup<ObjCBoxing>;
 
+def err_objc_non_runtime_protocol_in_protocol_expr : Error<
+  "cannot use a protocol declared 'objc_non_runtime_protocol' in a @protocol expression">;
 def err_objc_direct_on_protocol : Error<
   "'objc_direct' attribute cannot be applied to %select{methods|properties}0 "
   "declared in an Objective-C protocol">;
 def err_objc_direct_duplicate_decl : Error<
   "%select{|direct }0%select{method|property}1 declaration conflicts "
   "with previous %select{|direct }2declaration of %select{method|property}1 %3">;
 def err_objc_direct_impl_decl_mismatch : Error<
   "direct method was declared in %select{the primary interface|an extension|a category}0 "
   "but is implemented in %select{the primary interface|a category|a different category}1">;
 def err_objc_direct_missing_on_decl : Error<
   "direct method implementation was previously declared not direct">;
 def err_objc_direct_on_override : Error<
   "methods that %select{override superclass methods|implement protocol requirements}0 cannot be direct">;
 def err_objc_override_direct_method : Error<
   "cannot override a method that is declared direct by a superclass">;
 def warn_objc_direct_ignored : Warning<
   "%0 attribute isn't implemented by this Objective-C runtime">,
   InGroup<IgnoredAttributes>;
 def warn_objc_direct_property_ignored : Warning<
   "direct attribute on property %0 ignored (not implemented by this Objective-C runtime)">,
   InGroup<IgnoredAttributes>;
 def err_objc_direct_dynamic_property : Error<
   "direct property cannot be @dynamic">;
 
 def warn_conflicting_overriding_ret_types : Warning<
   "conflicting return type in "
   "declaration of %0%diff{: $ vs $|}1,2">,
   InGroup<OverridingMethodMismatch>, DefaultIgnore;
 
 def warn_conflicting_ret_types : Warning<
   "conflicting return type in "
   "implementation of %0%diff{: $ vs $|}1,2">,

clang/lib/AST/DeclObjC.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
+#include <queue>
 #include <utility>
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // ObjCListBase
 //===----------------------------------------------------------------------===//
 
ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
   ObjCProtocolDecl *Result =
       new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
                                    SourceLocation(), nullptr);
   Result->Data.setInt(!C.getLangOpts().Modules);
   return Result;
 }
 
+bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
+  return hasAttr<ObjCNonRuntimeProtocolAttr>();
+}
+
+void ObjCProtocolDecl::getImpliedProtocols(
+    llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const {
+  std::queue<const ObjCProtocolDecl *> WorkQueue;
+  WorkQueue.push(this);
+
+  while (!WorkQueue.empty()) {
+    const auto *PD = WorkQueue.front();
+    WorkQueue.pop();
+    for (const auto *Parent : PD->protocols()) {
+      const auto *Can = Parent->getCanonicalDecl();
+      auto Result = IPs.insert(Can);
+      if (Result.second)
+        WorkQueue.push(Parent);
+    }
+  }
+}
+
 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
   ObjCProtocolDecl *PDecl = this;
 
   if (Name == getIdentifier())
     return PDecl;
 
   for (auto *I : protocols())
     if ((PDecl = I->lookupProtocolNamed(Name)))

clang/lib/CodeGen/CGObjC.cpp

if (Optional<llvm::Value *> SpecializedResult =
           tryGenerateSpecializedMessageSend(CGF, ResultType, Receiver, Args,
                                             Sel, Method, isClassMessage)) {
     return RValue::get(SpecializedResult.getValue());
   }
   return GenerateMessageSend(CGF, Return, ResultType, Sel, Receiver, Args, OID,
                              Method);
 }
 
+static void AppendFirstImpliedRuntimeProtocols(
+    const ObjCProtocolDecl *PD,
+    llvm::UniqueVector<const ObjCProtocolDecl *> &PDs) {
+  if (!PD->isNonRuntimeProtocol()) {
+    const auto *Can = PD->getCanonicalDecl();
+    PDs.insert(Can);
+    return;
+  }
+
+  for (const auto *ParentPD : PD->protocols())
+    AppendFirstImpliedRuntimeProtocols(ParentPD, PDs);
+}
+
+std::vector<const ObjCProtocolDecl *>
+CGObjCRuntime::GetRuntimeProtocolList(ObjCProtocolDecl::protocol_iterator begin,
+                                      ObjCProtocolDecl::protocol_iterator end) {
+  std::vector<const ObjCProtocolDecl *> RuntimePds;
+  llvm::DenseSet<const ObjCProtocolDecl *> NonRuntimePDs;
+
+  for (; begin != end; ++begin) {
+    const auto *It = *begin;
+    const auto *Can = It->getCanonicalDecl();
+    if (Can->isNonRuntimeProtocol())
+      NonRuntimePDs.insert(Can);
+    else
+      RuntimePds.push_back(Can);
+  }
+
+  // If there are no non-runtime protocols then we can just stop now.
+  if (NonRuntimePDs.empty())
+    return RuntimePds;
+
+  // Else we have to search through the non-runtime protocol's inheritancy
+  // hierarchy DAG stopping whenever a branch either finds a runtime protocol or
+  // a non-runtime protocol without any parents. These are the "first-implied"
+  // protocols from a non-runtime protocol.
+  llvm::UniqueVector<const ObjCProtocolDecl *> FirstImpliedProtos;
+  for (const auto *PD : NonRuntimePDs)
+    AppendFirstImpliedRuntimeProtocols(PD, FirstImpliedProtos);
+
+  // Walk the Runtime list to get all protocols implied via the inclusion of
+  // this protocol, e.g. all protocols it inherits from including itself.
+  llvm::DenseSet<const ObjCProtocolDecl *> AllImpliedProtocols;
+  for (const auto *PD : RuntimePds) {
+    const auto *Can = PD->getCanonicalDecl();
+    AllImpliedProtocols.insert(Can);
+    Can->getImpliedProtocols(AllImpliedProtocols);
+  }
+
+  // Similar to above, walk the list of first-implied protocols to find the set
+  // all the protocols implied excluding the listed protocols themselves since
+  // they are not yet a part of the `RuntimePds` list.
+  for (const auto *PD : FirstImpliedProtos) {
+    PD->getImpliedProtocols(AllImpliedProtocols);
+  }
+
+  // From the first-implied list we have to finish building the final protocol
+  // list. If a protocol in the first-implied list was already implied via some
+  // inheritance path through some other protocols then it would be redundant to
+  // add it here and so we skip over it.
+  for (const auto *PD : FirstImpliedProtos) {
+    if (!AllImpliedProtocols.contains(PD)) {
+      RuntimePds.push_back(PD);
+    }
+  }
+
+  return RuntimePds;
+}
+
 /// Instead of '[[MyClass alloc] init]', try to generate
 /// 'objc_alloc_init(MyClass)'. This provides a code size improvement on the
 /// caller side, as well as the optimized objc_alloc.
 static Optional<llvm::Value *>
 tryEmitSpecializedAllocInit(CodeGenFunction &CGF, const ObjCMessageExpr *OME) {
   auto &Runtime = CGF.getLangOpts().ObjCRuntime;
   if (!Runtime.shouldUseRuntimeFunctionForCombinedAllocInit())
     return None;

clang/lib/CodeGen/CGObjCGNU.cpp

for (auto *M : Methods) {
       Method.finishAndAddTo(MethodArray);
     }
     MethodArray.finishAndAddTo(MethodList);
     return MethodList.finishAndCreateGlobal(".objc_protocol_method_list",
                                             CGM.getPointerAlign());
   }
   llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD)
     override {
-    SmallVector<llvm::Constant*, 16> Protocols;
-    for (const auto *PI : OCD->getReferencedProtocols())
+    const auto &ReferencedProtocols = OCD->getReferencedProtocols();
+    auto RuntimeProtocols = GetRuntimeProtocolList(ReferencedProtocols.begin(),
+                                                   ReferencedProtocols.end());
+    SmallVector<llvm::Constant *, 16> Protocols;
+    for (const auto *PI : RuntimeProtocols)
       Protocols.push_back(
           llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
             ProtocolPtrTy));
     return GenerateProtocolList(Protocols);
   }
 
   llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                               llvm::Value *cmd, MessageSendInfo &MSI) override {
else {
       assert(!OldGV);
       Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy,
         /*isConstant*/false,
         llvm::GlobalValue::ExternalLinkage, nullptr, SymName);
       return Protocol;
     }
 
     SmallVector<llvm::Constant*, 16> Protocols;
-    for (const auto *PI : PD->protocols())
+    auto RuntimeProtocols =
+        GetRuntimeProtocolList(PD->protocol_begin(), PD->protocol_end());
+    for (const auto *PI : RuntimeProtocols)
       Protocols.push_back(
           llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
             ProtocolPtrTy));
     llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
 
     // Collect information about methods
     llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;
     llvm::Constant *ClassMethodList, *OptionalClassMethodList;
void GenerateClass(const ObjCImplementationDecl *OID) override {
     classFields.addNullPointer(PtrTy);
     // IMP cxx_destruct;
     classFields.addNullPointer(PtrTy);
     // struct objc_class *subclass_list
     classFields.addNullPointer(PtrTy);
     // struct objc_class *sibling_class
     classFields.addNullPointer(PtrTy);
     // struct objc_protocol_list *protocols;
-    SmallVector<llvm::Constant*, 16> Protocols;
-    for (const auto *I : classDecl->protocols())
+    auto RuntimeProtocols = GetRuntimeProtocolList(classDecl->protocol_begin(),
+                                                   classDecl->protocol_end());
+    SmallVector<llvm::Constant *, 16> Protocols;
+    for (const auto *I : RuntimeProtocols)
       Protocols.push_back(
           llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I),
             ProtocolPtrTy));
     if (Protocols.empty())
       classFields.addNullPointer(PtrTy);
     else
       classFields.add(GenerateProtocolList(Protocols));
     // struct reference_list *extra_data;
CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
   Elements.add(MethodList);   /* .optional_class_methods */
   Elements.add(NULLPtr);      /* .properties */
   Elements.add(NULLPtr);      /* .optional_properties */
   return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),
                                         CGM.getPointerAlign());
 }
 
 void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
+  if (PD->isNonRuntimeProtocol())
+    return;
+
   std::string ProtocolName = PD->getNameAsString();
 
   // Use the protocol definition, if there is one.
   if (const ObjCProtocolDecl *Def = PD->getDefinition())
     PD = Def;
 
   SmallVector<std::string, 16> Protocols;
   for (const auto *PI : PD->protocols())
llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
   llvm::Constant *GS =
     fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
   llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
   return ptr;
 }
 
 llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const
     ObjCCategoryDecl *OCD) {
+  const auto &RefPro = OCD->getReferencedProtocols();
+  const auto RuntimeProtos =
+      GetRuntimeProtocolList(RefPro.begin(), RefPro.end());
   SmallVector<std::string, 16> Protocols;
-  for (const auto *PD : OCD->getReferencedProtocols())
+  for (const auto *PD : RuntimeProtos)
     Protocols.push_back(PD->getNameAsString());
   return GenerateProtocolList(Protocols);
 }
 
 void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
   const ObjCInterfaceDecl *Class = OCD->getClassInterface();
   std::string ClassName = Class->getNameAsString();
   std::string CategoryName = OCD->getNameAsString();
if (propertyImpl->getPropertyImplementation() ==
       };
       addPropertyMethod(propertyImpl->getGetterMethodDecl());
       addPropertyMethod(propertyImpl->getSetterMethodDecl());
     }
 
   llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl);
 
   // Collect the names of referenced protocols
+  auto RefProtocols = ClassDecl->protocols();
+  auto RuntimeProtocols =
+      GetRuntimeProtocolList(RefProtocols.begin(), RefProtocols.end());
   SmallVector<std::string, 16> Protocols;
-  for (const auto *I : ClassDecl->protocols())
+  for (const auto *I : RuntimeProtocols)
     Protocols.push_back(I->getNameAsString());
 
   // Get the superclass pointer.
   llvm::Constant *SuperClass;
   if (!SuperClassName.empty()) {
     SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
   } else {
     SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);

clang/lib/CodeGen/CGObjCMac.cpp

 #include "clang/Basic/LangOptions.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/CodeGen/ConstantInitBuilder.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/UniqueVector.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
struct objc_protocol_list {
     Protocol *list[];
   };
 */
 llvm::Constant *
 CGObjCMac::EmitProtocolList(Twine name,
                             ObjCProtocolDecl::protocol_iterator begin,
                             ObjCProtocolDecl::protocol_iterator end) {
   // Just return null for empty protocol lists
-  if (begin == end)
+  auto PDs = GetRuntimeProtocolList(begin, end);
+  if (PDs.empty())
     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
 
   ConstantInitBuilder builder(CGM);
   auto values = builder.beginStruct();
 
   // This field is only used by the runtime.
   values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
 
   // Reserve a slot for the count.
   auto countSlot = values.addPlaceholder();
 
   auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
-  for (; begin != end; ++begin) {
-    refsArray.add(GetProtocolRef(*begin));
-  }
+  for (const auto *Proto : PDs)
+    refsArray.add(GetProtocolRef(Proto));
+
   auto count = refsArray.size();
 
   // This list is null terminated.
   refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
 
   refsArray.finishAndAddTo(values);
   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
 

 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
 /// which will hold address of the protocol meta-data.
 ///
 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
                                                          const ObjCProtocolDecl *PD) {
 
   // This routine is called for @protocol only. So, we must build definition
   // of protocol's meta-data (not a reference to it!)
-  //
+  assert(!PD->isNonRuntimeProtocol() &&
+         "attempting to get a protocol ref to a static protocol.");
   llvm::Constant *Init =
     llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
                                    ObjCTypes.getExternalProtocolPtrTy());
 
   std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
   ProtocolName += PD->getObjCRuntimeNameAsString();
 
   CharUnits Align = CGF.getPointerAlign();
llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
   CGM.addCompilerUsedGlobal(GV);
   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
 }
 
 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
   const ObjCProtocolDecl *PD) {
   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
 
+  assert(!PD->isNonRuntimeProtocol() &&
+         "attempting to GetOrEmit a non-runtime protocol");
   if (!Entry) {
     // We use the initializer as a marker of whether this is a forward
     // reference or not. At module finalization we add the empty
     // contents for protocols which were referenced but never defined.
     llvm::SmallString<64> Protocol;
     llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
                                         << PD->getObjCRuntimeNameAsString();
 

 ///   struct _protocol_t[protocol_count];
 /// }
 /// @endcode
 ///
 llvm::Constant *
 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
                                       ObjCProtocolDecl::protocol_iterator begin,
                                       ObjCProtocolDecl::protocol_iterator end) {
+  // Just return null for empty protocol lists
+  auto Protocols = GetRuntimeProtocolList(begin, end);
+  if (Protocols.empty())
+    return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
+
   SmallVector<llvm::Constant *, 16> ProtocolRefs;
+  ProtocolRefs.reserve(Protocols.size());
 
-  // Just return null for empty protocol lists
-  if (begin == end)
+  for (const auto *PD : Protocols)
+    ProtocolRefs.push_back(GetProtocolRef(PD));
+
+  // If all of the protocols in the protocol list are objc_non_runtime_protocol
+  // just return null
+  if (ProtocolRefs.size() == 0)
     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
 
   // FIXME: We shouldn't need to do this lookup here, should we?
   SmallString<256> TmpName;
   Name.toVector(TmpName);
   llvm::GlobalVariable *GV =
     CGM.getModule().getGlobalVariable(TmpName.str(), true);
   if (GV)
     return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
 
   ConstantInitBuilder builder(CGM);
   auto values = builder.beginStruct();
   auto countSlot = values.addPlaceholder();
 
   // A null-terminated array of protocols.
   auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
-  for (; begin != end; ++begin)
-    array.add(GetProtocolRef(*begin));  // Implemented???
+  for (auto const &proto : ProtocolRefs)
+    array.add(proto);
   auto count = array.size();
   array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
 
   array.finishAndAddTo(values);
   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
 
   GV = finishAndCreateGlobal(values, Name, CGM);
   CGM.addCompilerUsedGlobal(GV);

clang/lib/CodeGen/CGObjCRuntime.h

 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOBJCRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGOBJCRUNTIME_H
 #include "CGBuilder.h"
 #include "CGCall.h"
 #include "CGCleanup.h"
 #include "CGValue.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/IdentifierTable.h" // Selector
+#include "llvm/ADT/UniqueVector.h"
 
 namespace llvm {
   class Constant;
   class Function;
   class Module;
   class StructLayout;
   class StructType;
   class Type;
GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
                            Selector Sel,
                            const ObjCInterfaceDecl *Class,
                            bool isCategoryImpl,
                            llvm::Value *Self,
                            bool IsClassMessage,
                            const CallArgList &CallArgs,
                            const ObjCMethodDecl *Method = nullptr) = 0;
 
+  /// Walk the list of protocol references from a class, category or
+  /// protocol to traverse the DAG formed from it's inheritance hierarchy. Find
+  /// the list of protocols that ends each walk at either a runtime
+  /// protocol or a non-runtime protocol with no parents. For the common case of
+  /// just a list of standard runtime protocols this just returns the same list
+  /// that was passed in.
+  std::vector<const ObjCProtocolDecl *>
+  GetRuntimeProtocolList(ObjCProtocolDecl::protocol_iterator begin,
+                         ObjCProtocolDecl::protocol_iterator end);
+
   /// Emit the code to return the named protocol as an object, as in a
   /// \@protocol expression.
   virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                            const ObjCProtocolDecl *OPD) = 0;
 
   /// Generate the named protocol.  Protocols contain method metadata but no
   /// implementations.
   virtual void GenerateProtocol(const ObjCProtocolDecl *OPD) = 0;

clang/lib/Sema/SemaDeclAttr.cpp

newAttr = S.mergeTypeVisibilityAttr(
         D, AL, (TypeVisibilityAttr::VisibilityType)type);
   } else {
     newAttr = S.mergeVisibilityAttr(D, AL, type);
   }
   if (newAttr)
     D->addAttr(newAttr);
 }
 
+static void handleObjCNonRuntimeProtocolAttr(Sema &S, Decl *D,
+                                             const ParsedAttr &AL) {
+  handleSimpleAttribute<ObjCNonRuntimeProtocolAttr>(S, D, AL);
+}
+
 static void handleObjCDirectAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   // objc_direct cannot be set on methods declared in the context of a protocol
   if (isa<ObjCProtocolDecl>(D->getDeclContext())) {
     S.Diag(AL.getLoc(), diag::err_objc_direct_on_protocol) << false;
     return;
   }
 
   if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) {
case ParsedAttr::AT_MinVectorWidth:
     handleMinVectorWidthAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Unavailable:
     handleAttrWithMessage<UnavailableAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCDirect:
     handleObjCDirectAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_ObjCNonRuntimeProtocol:
+    handleObjCNonRuntimeProtocolAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_ObjCDirectMembers:
     handleObjCDirectMembersAttr(S, D, AL);
     handleSimpleAttribute<ObjCDirectMembersAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCExplicitProtocolImpl:
     handleObjCSuppresProtocolAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Unused:

clang/lib/Sema/SemaExprObjC.cpp

ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
                                              SourceLocation LParenLoc,
                                              SourceLocation ProtoIdLoc,
                                              SourceLocation RParenLoc) {
   ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
   if (!PDecl) {
     Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
     return true;
   }
+  if (PDecl->isNonRuntimeProtocol())
+    Diag(ProtoLoc, diag::err_objc_non_runtime_protocol_in_protocol_expr)
+        << PDecl;
   if (!PDecl->hasDefinition()) {
     Diag(ProtoLoc, diag::err_atprotocol_protocol) << PDecl;
     Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl;
   } else {
     PDecl = PDecl->getDefinition();
   }
 
   QualType Ty = Context.getObjCProtoType();

clang/test/CodeGenObjC/non-runtime-protocol.m

+// RUN: not %clang_cc1 -emit-llvm -fobjc-arc -triple x86_64-apple-darwin10 %s -DPROTOEXPR -o - 2>&1 \
+// RUN:     | FileCheck -check-prefix=PROTOEXPR %s
+
+// RUN: %clang_cc1 -emit-llvm -fobjc-arc -triple x86_64-apple-darwin10 %s -DREDUNDANCY -o - \
+// RUN:     | FileCheck -check-prefix=REDUNDANCY1 %s
+// RUN: %clang_cc1 -emit-llvm -fobjc-arc -triple x86_64-apple-darwin10 %s -DREDUNDANCY -o - \
+// RUN:     | FileCheck -check-prefix=REDUNDANCY2 %s
+
+// RUN: %clang_cc1 -emit-llvm -fobjc-arc -triple x86_64-apple-darwin10 %s -DBASE -o - \
+// RUN:     | FileCheck -check-prefix=NONFRAGILE %s
+// RUN: %clang_cc1 -emit-llvm -fobjc-arc -triple x86_64-apple-darwin10 %s -DINHERITANCE -o - \
+// RUN:     | FileCheck -check-prefix=INHERITANCE %s
+
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin -fobjc-runtime=macosx-fragile-10.5 %s -DBASE -o - \
+// RUN:     | FileCheck -check-prefix=FRAGILE %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin -fobjc-runtime=macosx-fragile-10.5 %s -DINHERITANCE -o - \
+// RUN:     | FileCheck -check-prefix=FRAGILEINHERITANCE %s
+
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fobjc-runtime=gnustep %s -DBASE -o - \
+// RUN:     | FileCheck -check-prefix=GNU %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fobjc-runtime=gnustep %s -DINHERITANCE -o - \
+// RUN:     | FileCheck -check-prefix=GNUINHERITANCE %s
+//
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fobjc-runtime=gnustep-2 %s -DBASE -o - \
+// RUN:     | FileCheck -check-prefix=GNU2 %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fobjc-runtime=gnustep-2 %s -DINHERITANCE -o - \
+// RUN:     | FileCheck -check-prefix=GNU2INHERITANCE %s
+
+__attribute__((objc_root_class))
+@interface Root
+@end
+@implementation Root
+@end
+
+#ifdef REDUNDANCY
+// REDUNDANCY1-NOT: _OBJC_CLASS_PROTOCOLS_$_Implementer{{.*}}_OBJC_PROTOCOL_$_B
+// REDUNDANCY2:     _OBJC_CLASS_PROTOCOLS_$_Implementer{{.*}}_OBJC_PROTOCOL_$_C{{.*}}_OBJC_PROTOCOL_$_A
+@protocol C
+@end
+@protocol B <C>
+@end
+@protocol A <B>
+@end
+__attribute__((objc_non_runtime_protocol)) @protocol Alpha<A>
+@end
+__attribute__((objc_non_runtime_protocol)) @protocol Beta<B>
+@end
+@interface Implementer : Root <Alpha, Beta, C>
+@end
+@implementation Implementer
+@end
+#endif
+
+#ifdef BASE
+// Confirm that we're not emitting protocol information for the
+// NONFRAGILE-NOT: OBJC_CLASS_NAME{{.*}}NonRuntimeProtocol
+// NONFRAGILE-NOT: _OBJC_$_PROTOCOL_INSTANCE_METHODS_NonRuntimeProtocol
+// NONFRAGILE-NOT: _OBJC_$_PROTOCOL_CLASS_METHODS_NonRuntimeProtocol
+// NONFRAGILE-NOT: _OBJC_PROTOCOL_$_NonRuntimeProtocol
+// NONFRAGILE-NOT: _OBJC_LABEL_PROTOCOL_$_NonRuntimeProtocol
+// NONFRAGILE-NOT: _OBJC_CLASS_PROTOCOLS_$_NonRuntimeImplementer
+// FRAGILE-NOT: OBJC_CLASS_NAME_.{{.*}}"Runtime\00"
+// FRAGILE-NOT: OBJC_PROTOCOL_NonRuntime
+// FRAGILE_NOT: OBJC_PROTOCOLS_NonRuntimeImplementer
+// GNU-NOT: private unnamed_addr constant {{.*}} c"NonRuntimeProtocol\00"
+// GNU-NOT: @.objc_protocol {{.*}}
+// GNU2-NOT: private unnamed_addr constant {{.*}} c"NonRuntimeProtocol\00"
+// GNU2-NOT: @.objc_protocol {{.*}}
+__attribute__((objc_non_runtime_protocol))
+@protocol NonRuntimeProtocol
+- (void)doThing;
++ (void)doClassThing;
+@end
+// NONFRAGILE: @"_OBJC_METACLASS_RO_$_NonRuntimeImplementer" {{.*}} %struct._objc_protocol_list* null
+// NONFRAGILE: @"_OBJC_CLASS_RO_$_NonRuntimeImplementer" {{.*}} %struct._objc_protocol_list* null
+@interface NonRuntimeImplementer : Root <NonRuntimeProtocol>
+- (void)doThing;
++ (void)doClassThing;
+@end
+
+@implementation NonRuntimeImplementer
+- (void)doThing {
+}
++ (void)doClassThing {
+}
+@end
+#endif
+
+#ifdef PROTOEXPR
+__attribute__((objc_non_runtime_protocol))
+@protocol NonRuntimeProtocol
+@end
+void use() {
+  // PROTOEXPR: cannot use a protocol declared 'objc_non_runtime_protocol' in a @protocol expression
+  Protocol *p = @protocol(NonRuntimeProtocol);
+}
+#endif
+
+#ifdef INHERITANCE
+// Confirm that we only emit references to the non-runtime protocols and
+// properly walk the DAG to find the right protocols.
+// INHERITANCE: OBJC_PROTOCOL_$_R2{{.*}}
+// INHERITANCE: OBJC_PROTOCOL_$_R3{{.*}}
+// INHERITANCE: @"_OBJC_CLASS_PROTOCOLS_$_Implementer" {{.*}}_OBJC_PROTOCOL_$_R2{{.*}}_OBJC_PROTOCOL_$_R3
+
+// FRAGILEINHERITANCE: OBJC_PROTOCOL_R2
+// FRAGILEINHERITANCE: OBJC_PROTOCOL_R3
+// FRAGILEINHERITANCE: OBJC_CLASS_PROTOCOLS_Implementer{{.*}}OBJC_PROTOCOL_R2{{.*}}OBJC_PROTOCOL_R3
+
+// GNUINHERITANCE-DAG: @[[Proto1:[0-9]]]{{.*}}c"R1\00"
+// GNUINHERITANCE-DAG: [[P1Name:@.objc_protocol.[0-9]*]]{{.*}}@[[Proto1]]
+// GNUINHERITANCE-DAG: @[[Proto2:[0-9]]]{{.*}}c"R2\00"
+// GNUINHERITANCE-DAG: [[P2Name:@.objc_protocol.[0-9]+]]{{.*}}@[[Proto2]]
+// GNUINHERITANCE-DAG: @[[Proto3:[0-9]]]{{.*}}c"R3\00"
+// GNUINHERITANCE-DAG: [[P3Name:@.objc_protocol.[0-9]+]]{{.*}}@[[Proto3]]
+// GNUINHERITANCE-DAG: @.objc_protocol_list{{.*}}
+// GNUINHERITANCE: @.objc_protocol_list{{.*}}[[Proto3]]{{.*}}[[Proto2]]
+
+// GNU2INHERITANCE-DAG: @[[Proto1:[0-9]]]{{.*}}c"R1\00"
+// GNU2INHERITANCE-DAG: _OBJC_PROTOCOL_R1{{.*}}@[[Proto1]]
+// GNU2INHERITANCE-DAG: @[[Proto2:[0-9]]]{{.*}}c"R2\00"
+// GNU2INHERITANCE-DAG: _OBJC_PROTOCOL_R2{{.*}}@[[Proto2]]
+// GNU2INHERITANCE-DAG: @[[Proto3:[0-9]]]{{.*}}c"R3\00"
+// GNU2INHERITANCE-DAG: _OBJC_PROTOCOL_R3{{.*}}@[[Proto3]]
+// GNU2INHERITANCE: @.objc_protocol_list{{.*}}_OBJC_PROTOCOL_R2{{.*}}_OBJC_PROTOCOL_R3
+@protocol R1
+@end
+@protocol R2
+@end
+@protocol R3 <R1>
+@end
+__attribute__((objc_non_runtime_protocol)) @protocol N3
+@end
+__attribute__((objc_non_runtime_protocol)) @protocol N1<R3, R2, N3>
+@end
+__attribute__((objc_non_runtime_protocol)) @protocol N2<N1, R2>
+@end
+@interface Implementer : Root <N2, R2>
+@end
+@implementation Implementer
+@end
+#endif

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: ObjCDesignatedInitializer (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCDirect (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCDirectMembers (SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_interface, SubjectMatchRule_objc_category)
 // CHECK-NEXT: ObjCException (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCExplicitProtocolImpl (SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCExternallyRetained (SubjectMatchRule_variable_not_is_parameter, SubjectMatchRule_function, SubjectMatchRule_block, SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCMethodFamily (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCNonLazyClass (SubjectMatchRule_objc_interface, SubjectMatchRule_objc_implementation)
+// CHECK-NEXT: ObjCNonRuntimeProtocol (SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCPreciseLifetime (SubjectMatchRule_variable)
 // CHECK-NEXT: ObjCRequiresPropertyDefs (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCRequiresSuper (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCReturnsInnerPointer (SubjectMatchRule_objc_method, SubjectMatchRule_objc_property)
 // CHECK-NEXT: ObjCRootClass (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCRuntimeName (SubjectMatchRule_objc_interface, SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCRuntimeVisible (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCSubclassingRestricted (SubjectMatchRule_objc_interface)