[clang] CodeGen: Make getOrEmitProtocol public for Swift

[aschwaighofer]

Summary

Swift would like to use clang's abis to emit protocol declarations.

It needs to a hook to register when inherited protocols are emitted.

This commits adds the public API:

emitProtocolDecl(CodeGenModule &CGM, const ObjCProtocolDecl *p,

llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
    createProtocolReference);

rdar://60888524

[rjmccall]

clang/include/clang/CodeGen/CodeGenABITypes.h

149

I would call this emitObjCProtocolObject or something, and maybe say in the comment:

Get a pointer to a protocol object for the given declaration, emitting it if it hasn't already been emitted in this translation unit. Note that the ABI for emitting a protocol reference in code (e.g. for a @protocol expression) in most runtimes is not as simple as just materializing a pointer to this object.

Can you explain the need for the callback? Are you expecting to use this for Swift-declared protocols by synthesizing an ObjC protocol declaration for them? I can see why you'd need a callback in that case.

[aschwaighofer]

Can you explain the need for the callback? Are you expecting to use this for Swift-declared protocols by synthesizing an ObjC protocol declaration for them? I can see why you'd need a callback in that case.

The objective C protocol references other protocols in its inherited list. Swift has an internal list that keeps track of those protocols references and makes sure to initialized them for the debugger and also makes sure that the underlying protocol structure is emitted. The call back is to keep this list in sync.

[aschwaighofer]

• Change API name to emitObjCProtocolObject.
• Make stuff compile on current ToT.

[aschwaighofer]

clang/include/clang/CodeGen/CodeGenABITypes.h

149

Can you explain the need for the callback? Are you expecting to use this for Swift-declared protocols by synthesizing an ObjC protocol declaration for them? I can see why you'd need a callback in that case.

The objective C protocol references other protocols in its inherited list. Swift has an internal list that keeps track of those protocols references and makes sure to initialized them for the debugger and also makes sure that the underlying protocol structure is emitted. The call back is to keep this list in sync.

[rjmccall]

clang/include/clang/CodeGen/CodeGenABITypes.h

149

The problem is that this is really, really intertwined with the ABI logic. This callback basically has to know exactly how the caller is calling it and and what it's expected to build in response.

Swift code can use arbitrary inline Objective-C functions and therefore emit arbitrary Objective-C code. Is there an approach that handles that while also being less invasive for Clang IRGen? Can we, e.g., inspect the built llvm::Module to figure out retroactively what protocol refs we need to update dynamically instead of trying to track them during the build?

[aschwaighofer]

• Remove callback. Swift can inspect the generated IR and update it.

[aschwaighofer]

clang/include/clang/CodeGen/CodeGenABITypes.h

149

Yes. I think you are right. Swift can inspect the generated IR and update it.

https://github.com/aschwaighofer/swift/commit/d29daf41ec3a51405df31591dad6fea97dbc58e0

I have removed the callback.

[rjmccall]

clang/lib/CodeGen/CGObjCGNU.cpp

623

I think this is just the (unfortunately-named) GenerateProtocolRef (the one that just takes a protocol and not a CGF).

clang/lib/CodeGen/CGObjCRuntime.h

217

Can this name more closely parallel the "external" name, like getOrEmitProtocolObject?

Also, I think we're incrementally lowercasing new method names.

[aschwaighofer]

clang/lib/CodeGen/CGObjCRuntime.h

217

This is an already existing method. I just moved it higher in the class hierarchy to CGObjCRuntime from CGObjCMac so that it is callable from getOrEmitProtocolObject.

[aschwaighofer]

clang/lib/CodeGen/CGObjCRuntime.h

217

s/getOrEmitProtocolObject/emitObjCProtocolObject

[rjmccall]

clang/lib/CodeGen/CGObjCRuntime.h

217

I see. Well, in that case, I won't ask you to rename it, but please do implement it for the GNU runtime as I mentioned.

[aschwaighofer]

• Implement for the GNU runtimes

[aschwaighofer]

clang/lib/CodeGen/CGObjCRuntime.h

217

Done. I introduced
CGObjCGNU::GenerateProtocolRef(const ObjCProtocolDecl *PD) because it only existed in the CGObjCGNUstep2 subclass.

[rjmccall]

Thanks, LGTM.

clang/include/clang/CodeGen/CodeGenABITypes.h

 #ifndef LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
 #define LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
 
 #include "clang/AST/CanonicalType.h"
 #include "clang/AST/Type.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 
 namespace llvm {
+  class Constant;
   class DataLayout;
   class Module;
   class Function;
   class FunctionType;
   class Type;
 }
 
 namespace clang {
 class ASTContext;
 class CXXRecordDecl;
 class CXXMethodDecl;
 class CodeGenOptions;
 class CoverageSourceInfo;
 class DiagnosticsEngine;
 class HeaderSearchOptions;
 class ObjCMethodDecl;
+class ObjCProtocolDecl;
 class PreprocessorOptions;
 
 namespace CodeGen {
 class CGFunctionInfo;
 class CodeGenModule;
 
 const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM,
                                                       const ObjCMethodDecl *MD,

 /// Returns the destructor for a C struct with non-trivially copyable fields,
 /// generating it if necessary. The returned function uses the `cdecl` calling
 /// convention, returns void, and takes a single argument that is a pointer to
 /// the address of the struct.
 llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM,
                                                CharUnits DstAlignment,
                                                bool IsVolatile, QualType QT);
 
+/// Get a pointer to a protocol object for the given declaration, emitting it if
+/// it hasn't already been emitted in this translation unit. Note that the ABI
+/// for emitting a protocol reference in code (e.g. for a @protocol expression)
+/// in most runtimes is not as simple as just materializing a pointer to this
+/// object.
+/// \p createProtocolReference is called by the implementation when the protocol
+/// \p p references another protocol.
+llvm::Constant *emitObjCProtocolObject(
+    CodeGenModule &CGM, const ObjCProtocolDecl *p,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        createProtocolReference);
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif

clang/lib/CodeGen/CGObjCGNU.cpp

void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
                                     const ObjCMethodDecl *OMD,
                                     const ObjCContainerDecl *CD) override;
   void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
   void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
   void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override;
   llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                    const ObjCProtocolDecl *PD) override;
   void GenerateProtocol(const ObjCProtocolDecl *PD) override;
+
+  llvm::Constant *getOrEmitProtocol(
+      const ObjCProtocolDecl *OPD,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          createProtocolReference) override;
   llvm::Function *ModuleInitFunction() override;
   llvm::FunctionCallee GetPropertyGetFunction() override;
   llvm::FunctionCallee GetPropertySetFunction() override;
   llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                        bool copy) override;
   llvm::FunctionCallee GetSetStructFunction() override;
   llvm::FunctionCallee GetGetStructFunction() override;
   llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
   if (!protocol)
     GenerateProtocol(PD);
   assert(protocol && "Unknown protocol");
   llvm::Type *T =
     CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
   return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
 }
 
+llvm::Constant *CGObjCGNU::getOrEmitProtocol(
+    const ObjCProtocolDecl *PD,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        createProtocolReference) {
+  llvm_unreachable("not implemented");
+}
+
 llvm::Constant *
 CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
   llvm::Constant *ProtocolList = GenerateProtocolList({});
   llvm::Constant *MethodList = GenerateProtocolMethodList({});
   MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty);
   // Protocols are objects containing lists of the methods implemented and
   // protocols adopted.
   ConstantInitBuilder Builder(CGM);

clang/lib/CodeGen/CGObjCMac.cpp

void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
                                     const ObjCMethodDecl *OMD,
                                     const ObjCContainerDecl *CD) override;
 
   void GenerateProtocol(const ObjCProtocolDecl *PD) override;
 
   /// GetOrEmitProtocol - Get the protocol object for the given
   /// declaration, emitting it if necessary. The return value has type
   /// ProtocolPtrTy.
-  virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
+  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
 
   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
   /// object for the given declaration, emitting it if needed. These
   /// forward references will be filled in with empty bodies if no
   /// definition is seen. The return value has type ProtocolPtrTy.
   virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
 
   virtual llvm::Constant *getNSConstantStringClassRef() = 0;
private:
   void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
                                      const ObjCMethodDecl *MD);
 
   /// EmitMethodList - Emit the method list for the given
   /// implementation. The return value has type MethodListPtrTy.
   llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
                                  ArrayRef<const ObjCMethodDecl *> Methods);
 
-  /// GetOrEmitProtocol - Get the protocol object for the given
+  /// getOrEmitProtocol - Get the protocol object for the given
   /// declaration, emitting it if necessary. The return value has type
   /// ProtocolPtrTy.
-  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
+  /// \p getProtocolReference is called by the implementation when a
+  /// reference to another protocol is needed.
+  llvm::Constant *getOrEmitProtocol(
+      const ObjCProtocolDecl *OPD,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          getProtocolReference) override;
 
   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
   /// object for the given declaration, emitting it if needed. These
   /// forward references will be filled in with empty bodies if no
   /// definition is seen. The return value has type ProtocolPtrTy.
   llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
 
   /// EmitProtocolExtension - Generate the protocol extension
   /// structure used to store optional instance and class methods, and
   /// protocol properties. The return value has type
   /// ProtocolExtensionPtrTy.
   llvm::Constant *
   EmitProtocolExtension(const ObjCProtocolDecl *PD,
                         const ProtocolMethodLists &methodLists);
 
   /// EmitProtocolList - Generate the list of referenced
   /// protocols. The return value has type ProtocolListPtrTy.
-  llvm::Constant *EmitProtocolList(Twine Name,
-                                   ObjCProtocolDecl::protocol_iterator begin,
-                                   ObjCProtocolDecl::protocol_iterator end);
+  llvm::Constant *EmitProtocolList(
+      Twine Name, ObjCProtocolDecl::protocol_iterator begin,
+      ObjCProtocolDecl::protocol_iterator end,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          getProtocolRef);
 
   /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
   /// for the given selector.
   llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
   Address EmitSelectorAddr(Selector Sel);
 
 public:
   CGObjCMac(CodeGen::CodeGenModule &cgm);
private:
   /// interface ivars will be emitted. The return value has type
   /// IvarListnfABIPtrTy.
   llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
 
   llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
                                     const ObjCIvarDecl *Ivar,
                                     unsigned long int offset);
 
-  /// GetOrEmitProtocol - Get the protocol object for the given
+  /// getOrEmitProtocol - Get the protocol object for the given
   /// declaration, emitting it if necessary. The return value has type
   /// ProtocolPtrTy.
-  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
+  /// \p getProtocolReference is called by the implementation when a
+  /// reference to another protocol is needed.
+  llvm::Constant *getOrEmitProtocol(
+      const ObjCProtocolDecl *OPD,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          createProtocolReference) override;
 
   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
   /// object for the given declaration, emitting it if needed. These
   /// forward references will be filled in with empty bodies if no
   /// definition is seen. The return value has type ProtocolPtrTy.
   llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
 
   /// EmitProtocolList - Generate the list of referenced
   /// protocols. The return value has type ProtocolListPtrTy.
-  llvm::Constant *EmitProtocolList(Twine Name,
-                                   ObjCProtocolDecl::protocol_iterator begin,
-                                   ObjCProtocolDecl::protocol_iterator end);
+  llvm::Constant *EmitProtocolList(
+      Twine Name, ObjCProtocolDecl::protocol_iterator begin,
+      ObjCProtocolDecl::protocol_iterator end,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          getProtocolRef);
 
   CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
                                         ReturnValueSlot Return,
                                         QualType ResultType,
                                         Selector Sel,
                                         llvm::Value *Receiver,
                                         QualType Arg0Ty,
                                         bool IsSuper,

 
 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
   if (DefinedProtocols.count(PD->getIdentifier()))
     return GetOrEmitProtocol(PD);
 
   return GetOrEmitProtocolRef(PD);
 }
 
+llvm::Constant *CGObjCCommonMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
+  return getOrEmitProtocol(
+      PD, [this](const ObjCProtocolDecl *p) -> llvm::Constant * {
+        return this->GetProtocolRef(p);
+      });
+}
+
 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
                CodeGenFunction &CGF,
                const ObjCInterfaceDecl *ID,
                ObjCCommonTypesHelper &ObjCTypes) {
   llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
 
   llvm::Value *className = CGF.CGM
                                .GetAddrOfConstantCString(std::string(

 char *protocol_name;
 struct _objc_protocol_list *protocol_list;
 struct _objc__method_prototype_list *instance_methods;
 struct _objc__method_prototype_list *class_methods
 };
 
 See EmitProtocolExtension().
 */
-llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
+llvm::Constant *CGObjCMac::getOrEmitProtocol(
+    const ObjCProtocolDecl *PD,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        getProtocolRef) {
   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
 
   // Early exit if a defining object has already been generated.
   if (Entry && Entry->hasInitializer())
     return Entry;
 
   // Use the protocol definition, if there is one.
   if (const ObjCProtocolDecl *Def = PD->getDefinition())
     PD = Def;
 
   // FIXME: I don't understand why gcc generates this, or where it is
   // resolved. Investigate. Its also wasteful to look this up over and over.
   LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
 
   // Construct method lists.
   auto methodLists = ProtocolMethodLists::get(PD);
 
   ConstantInitBuilder builder(CGM);
   auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
   values.add(EmitProtocolExtension(PD, methodLists));
   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
   values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
-                              PD->protocol_begin(), PD->protocol_end()));
+                              PD->protocol_begin(), PD->protocol_end(),
+                              getProtocolRef));
   values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::RequiredInstanceMethods));
   values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::RequiredClassMethods));
 
   if (Entry) {
     // Already created, update the initializer.
     assert(Entry->hasPrivateLinkage());

 
 /*
   struct objc_protocol_list {
     struct objc_protocol_list *next;
     long count;
     Protocol *list[];
   };
 */
-llvm::Constant *
-CGObjCMac::EmitProtocolList(Twine name,
-                            ObjCProtocolDecl::protocol_iterator begin,
-                            ObjCProtocolDecl::protocol_iterator end) {
+llvm::Constant *CGObjCMac::EmitProtocolList(
+    Twine name, ObjCProtocolDecl::protocol_iterator begin,
+    ObjCProtocolDecl::protocol_iterator end,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        getProtocolRef) {
   // Just return null for empty protocol lists
   if (begin == end)
     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));
+    auto protocolRef = getProtocolRef(*begin);
+    if (protocolRef->getType() != ObjCTypes.ProtocolPtrTy)
+      protocolRef =
+          llvm::ConstantExpr::getBitCast(protocolRef, ObjCTypes.ProtocolPtrTy);
+    refsArray.add(protocolRef);
   }
   auto count = refsArray.size();
 
   // This list is null terminated.
   refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
 
   refsArray.finishAndAddTo(values);
   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
 
   Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
                             Methods[InstanceMethods]));
   Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
                             Methods[ClassMethods]));
   if (Category) {
     Values.add(
         EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
-                         Category->protocol_begin(), Category->protocol_end()));
+                         Category->protocol_begin(), Category->protocol_end(),
+                         [this](const ObjCProtocolDecl *p) -> llvm::Constant * {
+                           return this->GetProtocolRef(p);
+                         }));
   } else {
     Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
   }
   Values.addInt(ObjCTypes.IntTy, Size);
 
   // If there is no category @interface then there can be no properties.
   if (Category) {
     Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
 
   std::string ClassName = ID->getNameAsString();
   // FIXME: Gross
   ObjCInterfaceDecl *Interface =
     const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
   llvm::Constant *Protocols =
       EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
                        Interface->all_referenced_protocol_begin(),
-                       Interface->all_referenced_protocol_end());
+                       Interface->all_referenced_protocol_end(),
+                       [this](const ObjCProtocolDecl *p) -> llvm::Constant * {
+                         return this->GetProtocolRef(p);
+                       });
   unsigned Flags = FragileABI_Class_Factory;
   if (ID->hasNonZeroConstructors() || ID->hasDestructors())
     Flags |= FragileABI_Class_HasCXXStructors;
 
   bool hasMRCWeak = false;
 
   if (CGM.getLangOpts().ObjCAutoRefCount)
     Flags |= FragileABI_Class_CompiledByARC;
llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
   values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
                             (flags & NonFragileABI_Class_Meta)
                                ? MethodListType::ClassMethods
                                : MethodListType::InstanceMethods,
                             methods));
 
   const ObjCInterfaceDecl *OID = ID->getClassInterface();
   assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
-  values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
-                                + OID->getObjCRuntimeNameAsString(),
-                              OID->all_referenced_protocol_begin(),
-                              OID->all_referenced_protocol_end()));
+  values.add(EmitProtocolList(
+      "_OBJC_CLASS_PROTOCOLS_$_" + OID->getObjCRuntimeNameAsString(),
+      OID->all_referenced_protocol_begin(), OID->all_referenced_protocol_end(),
+      [this](const ObjCProtocolDecl *p) -> llvm::Constant * {
+        return this->GetProtocolRef(p);
+      }));
 
   if (flags & NonFragileABI_Class_Meta) {
     values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
     values.add(GetIvarLayoutName(nullptr, ObjCTypes));
     values.add(EmitPropertyList(
         "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
         ID, ID->getClassInterface(), ObjCTypes, true));
   } else {
values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
                             classMethods));
 
   const ObjCCategoryDecl *Category =
     Interface->FindCategoryDeclaration(OCD->getIdentifier());
   if (Category) {
     SmallString<256> ExtName;
     llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
                                        << OCD->getName();
-    values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
-                                   + Interface->getObjCRuntimeNameAsString() + "_$_"
-                                   + Category->getName(),
-                                Category->protocol_begin(),
-                                Category->protocol_end()));
+    values.add(
+        EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_" +
+                             Interface->getObjCRuntimeNameAsString() + "_$_" +
+                             Category->getName(),
+                         Category->protocol_begin(), Category->protocol_end(),
+                         [this](const ObjCProtocolDecl *p) -> llvm::Constant * {
+                           return this->GetProtocolRef(p);
+                         }));
     values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
                                 OCD, Category, ObjCTypes, false));
     values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
                                 OCD, Category, ObjCTypes, true));
   } else {
     values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
                                      nullptr, Protocol);
     if (!CGM.getTriple().isOSBinFormatMachO())
       Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
   }
 
   return Entry;
 }
 
-/// GetOrEmitProtocol - Generate the protocol meta-data:
+/// getOrEmitProtocol - Generate the protocol meta-data:
 /// @code
 /// struct _protocol_t {
 ///   id isa;  // NULL
 ///   const char * const protocol_name;
 ///   const struct _protocol_list_t * protocol_list; // super protocols
 ///   const struct method_list_t * const instance_methods;
 ///   const struct method_list_t * const class_methods;
 ///   const struct method_list_t *optionalInstanceMethods;
 ///   const struct method_list_t *optionalClassMethods;
 ///   const struct _prop_list_t * properties;
 ///   const uint32_t size;  // sizeof(struct _protocol_t)
 ///   const uint32_t flags;  // = 0
 ///   const char ** extendedMethodTypes;
 ///   const char *demangledName;
 ///   const struct _prop_list_t * class_properties;
 /// }
 /// @endcode
 ///
 
-llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
-  const ObjCProtocolDecl *PD) {
+llvm::Constant *CGObjCNonFragileABIMac::getOrEmitProtocol(
+    const ObjCProtocolDecl *PD,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        getProtocolRef) {
   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
 
   // Early exit if a defining object has already been generated.
   if (Entry && Entry->hasInitializer())
     return Entry;
 
   // Use the protocol definition, if there is one.
   assert(PD->hasDefinition() &&
          "emitting protocol metadata without definition");
   PD = PD->getDefinition();
 
   auto methodLists = ProtocolMethodLists::get(PD);
 
   ConstantInitBuilder builder(CGM);
   auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
 
   // isa is NULL
   values.addNullPointer(ObjCTypes.ObjectPtrTy);
   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
-  values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
-                                + PD->getObjCRuntimeNameAsString(),
-                               PD->protocol_begin(),
-                               PD->protocol_end()));
+  values.add(EmitProtocolList(
+      "_OBJC_$_PROTOCOL_REFS_" + PD->getObjCRuntimeNameAsString(),
+      PD->protocol_begin(), PD->protocol_end(), getProtocolRef));
   values.add(methodLists.emitMethodList(this, PD,
                                  ProtocolMethodLists::RequiredInstanceMethods));
   values.add(methodLists.emitMethodList(this, PD,
                                  ProtocolMethodLists::RequiredClassMethods));
   values.add(methodLists.emitMethodList(this, PD,
                                  ProtocolMethodLists::OptionalInstanceMethods));
   values.add(methodLists.emitMethodList(this, PD,
                                  ProtocolMethodLists::OptionalClassMethods));

 /// EmitProtocolList - Generate protocol list meta-data:
 /// @code
 /// struct _protocol_list_t {
 ///   long protocol_count;   // Note, this is 32/64 bit
 ///   struct _protocol_t[protocol_count];
 /// }
 /// @endcode
 ///
-llvm::Constant *
-CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
-                                      ObjCProtocolDecl::protocol_iterator begin,
-                                      ObjCProtocolDecl::protocol_iterator end) {
+llvm::Constant *CGObjCNonFragileABIMac::EmitProtocolList(
+    Twine Name, ObjCProtocolDecl::protocol_iterator begin,
+    ObjCProtocolDecl::protocol_iterator end,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        getProtocolRef) {
   SmallVector<llvm::Constant *, 16> ProtocolRefs;
 
   // Just return null for empty protocol lists
   if (begin == end)
     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 (; begin != end; ++begin) {
+    auto protocolRef = getProtocolRef(*begin);
+    if (protocolRef->getType() != ObjCTypes.ProtocolnfABIPtrTy)
+      protocolRef = llvm::ConstantExpr::getBitCast(
+          protocolRef, ObjCTypes.ProtocolnfABIPtrTy);
+    array.add(protocolRef);
+  }
   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

public:
   /// \@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;
 
+  /// getOrEmitProtocol - Get the protocol object for the given
+  /// declaration, emitting it if necessary. The return value has type
+  /// ProtocolPtrTy.
+  /// \p getProtocolReference is called by the implementation when a
+  /// reference to another protocol is needed.
+  virtual llvm::Constant *getOrEmitProtocol(
+      const ObjCProtocolDecl *OPD,
+      llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+          getProtocolReference) = 0;
+
   /// Generate a function preamble for a method with the specified
   /// types.
 
   // FIXME: Current this just generates the Function definition, but really this
   // should also be generating the loads of the parameters, as the runtime
   // should have full control over how parameters are passed.
   virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
                                          const ObjCContainerDecl *CD) = 0;

clang/lib/CodeGen/CGObjCRuntime.cpp

 //==- CGObjCRuntime.cpp - Interface to Shared Objective-C Runtime Features ==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This abstract class defines the interface for Objective-C runtime-specific
 // code generation.  It provides some concrete helper methods for functionality
 // shared between all (or most) of the Objective-C runtimes supported by clang.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CGObjCRuntime.h"
-#include "CGCleanup.h"
 #include "CGCXXABI.h"
+#include "CGCleanup.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
+#include "clang/CodeGen/CodeGenABITypes.h"
 #include "llvm/Support/SaveAndRestore.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
                                               const ObjCInterfaceDecl *OID,
                                               const ObjCIvarDecl *Ivar) {
CGObjCRuntime::getMessageSendInfo(const ObjCMethodDecl *method,
   const CGFunctionInfo &argsInfo =
     CGM.getTypes().arrangeUnprototypedObjCMessageSend(resultType, callArgs);
 
   // Derive the signature to call from that.
   llvm::PointerType *signatureType =
     CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo();
   return MessageSendInfo(argsInfo, signatureType);
 }
+
+llvm::Constant *clang::CodeGen::emitObjCProtocolObject(
+    CodeGenModule &CGM, const ObjCProtocolDecl *protocol,
+    llvm::function_ref<llvm::Constant *(const ObjCProtocolDecl *)>
+        createProtocolReference) {
+  return CGM.getObjCRuntime().getOrEmitProtocol(protocol,
+                                                createProtocolReference);
+}