[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 DataLayout;
-  class Module;
-  class Function;
-  class FunctionType;
-  class Type;
+class Constant;
 }
 
 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.
+llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM,
+                                       const ObjCProtocolDecl *p);
 }  // 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;
+
+  virtual llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD);
+
+  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override {
+    return GenerateProtocolRef(PD);
+  }
+
   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::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) {
     ProtocolBuilder.add(ProtocolArray);
     return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list",
         CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage);
   }
 
   void GenerateProtocol(const ObjCProtocolDecl *PD) override {
     // Do nothing - we only emit referenced protocols.
   }
-  llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) {
+  llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) override {
     std::string ProtocolName = PD->getNameAsString();
     auto *&Protocol = ExistingProtocols[ProtocolName];
     if (Protocol)
       return Protocol;
 
     EmittedProtocol = true;
 
     auto SymName = SymbolForProtocol(ProtocolName);
CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) {
   }
   Elements.finishAndAddTo(ProtocolList);
   return ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
                                             CGM.getPointerAlign());
 }
 
 llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
                                             const ObjCProtocolDecl *PD) {
+  auto protocol = GenerateProtocolRef(PD);
+  llvm::Type *T =
+      CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
+  return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
+}
+
+llvm::Constant *CGObjCGNU::GenerateProtocolRef(const ObjCProtocolDecl *PD) {
   llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()];
   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));
+  return protocol;
 }
 
 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

clang/lib/CodeGen/CGObjCMac.cpp

llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
                                        const ObjCContainerDecl *CD);
 
   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;
-
   /// 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;
 

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.
+  virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) = 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) {
+  return CGM.getObjCRuntime().GetOrEmitProtocol(protocol);
+}