CodeGen: Fix LLVM assertion if Swift and Clang emit Objective-C class reference in same LLVM module

[slavapestov]

Summary

This patch fixes an issue that can come up when Swift and Clang are emitting declarations into the same LLVM module.

Objective-C class literals result in the emission of a global variable named OBJC_CLASS_$_<ClassName>. Clang and Swift emit this variable with different types, resulting in an LLVM assertion firing. This patch changes Clang to be more resilient in the case where the global has already been emitted, wrapping it in a cast constexpr instead of crashing.

[rjmccall]

It just occurred to me that there is a way to test this in Clang with the asm-label extension:

int Foo_class asm("OBJC_CLASS_$_Foo");

Of course, you'll have to actually use it from somewhere, or define it, in order for it to actually show up in the IR and cause a conflict.

You should probably also test that we do something sane if the caller is making a definition but one already exists. An error counts as "sane"; just make sure you return a GlobalVariable of the right type. There's model code for this in GetOrCreateLLVMFunction, although it's okay for the diagnostic here to be worse than that one.

[slavapestov]

Unfortunately the asm label attribute doesn’t seem to work in this case, at least on Darwin. I get two symbols in the IR, with the asm label having the \01 prefix from MangleContext::mangleName():

@"\01OBJC_CLASS_$_NSNumber" = common global %struct.art_class* null, align 8
@"OBJC_CLASS_$_NSNumber" = external global %struct._class_t

As for the diagnostic, is this what you had in mind?

commit 4d4f15ffc4d6a72357fa4cee8e2197a03afe6b51
Author: Slava Pestov <[e-mail]>
Date: Fri Oct 23 23:57:56 2015 -0700

CodeGen: More robust handling of type conflicts in GetClassGlobal()

diff --git a/lib/CodeGen/CGObjCMac.cpp b/lib/CodeGen/CGObjCMac.cpp
index 31e98b9..e5ef767 100644

• a/lib/CodeGen/CGObjCMac.cpp

+++ b/lib/CodeGen/CGObjCMac.cpp
@@ -6692,16 +6692,31 @@ CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name,

llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);

• if (!GV)
• GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
• false, L, nullptr, Name);

+ // If it doesn't exist, create it with the right type.
+ if (!GV) {
+ return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
+ false, L, nullptr, Name);
+ }

assert(GV->getLinkage() == L);

• if (ForDefinition ||
• GV->getValueType() == ObjCTypes.ClassnfABITy)

+ // If it already exists, we might need to bitcast.
+ if (GV->getValueType() == ObjCTypes.ClassnfABITy)

return GV;

+ if (ForDefinition) {
+ DiagnosticsEngine &Diags = CGM.getDiags();
+ unsigned DiagID = Diags.getCustomDiagID(
+ DiagnosticsEngine::Error,
+ "global variable %0 already defined with wrong type");
+ Diags.Report(SourceLocation(), DiagID) << Name;
+
+ Return a new global in this case, with the right type, since the caller
+ doesn't expect a constexpr
+ return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
+ false, L, nullptr, Name);
+ }
+

return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ClassnfABIPtrTy);

}

lib/CodeGen/CGObjCGNU.cpp

llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
                                      const CGBlockInfo &blockInfo) override {
     return NULLPtr;
   }
 
   llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
     return NULLPtr;
   }
 
-  llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
-                                       bool Weak = false) override {
+  llvm::Constant *GetClassGlobal(const std::string &Name,
+                                 bool ForDefinition,
+                                 bool Weak) override {
     return nullptr;
   }
 };
 /// Class representing the legacy GCC Objective-C ABI.  This is the default when
 /// -fobjc-nonfragile-abi is not specified.
 ///
 /// The GCC ABI target actually generates code that is approximately compatible
 /// with the new GNUstep runtime ABI, but refrains from using any features that

lib/CodeGen/CGObjCMac.cpp

LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
                               llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
                               unsigned CVRQualifiers) override;
   llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                               const ObjCInterfaceDecl *Interface,
                               const ObjCIvarDecl *Ivar) override;
 
   /// GetClassGlobal - Return the global variable for the Objective-C
   /// class of the given name.
-  llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
-                                       bool Weak = false) override {
+  llvm::Constant *GetClassGlobal(const std::string &Name,
+                                 bool ForDefinition,
+                                 bool Weak) override {
     llvm_unreachable("CGObjCMac::GetClassGlobal");
   }
 };
 
 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
 private:
   ObjCNonFragileABITypesHelper ObjCTypes;
   llvm::GlobalVariable* ObjCEmptyCacheVar;
CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
                                         llvm::Value *Receiver,
                                         QualType Arg0Ty,
                                         bool IsSuper,
                                         const CallArgList &CallArgs,
                                         const ObjCMethodDecl *Method);
   
   /// GetClassGlobal - Return the global variable for the Objective-C
   /// class of the given name.
-  llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
-                                       bool Weak = false) override;
+  llvm::Constant *GetClassGlobal(const std::string &Name,
+                                 bool ForDefinition,
+                                 bool Weak) override;
 
   /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
   /// for the given class reference.
   llvm::Value *EmitClassRef(CodeGenFunction &CGF,
                             const ObjCInterfaceDecl *ID);
   
   llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
                                   IdentifierInfo *II, bool Weak,
llvm::GlobalVariable *CGObjCNonFragileABIMac::BuildClassMetaData(
   };
   if (!Values[1])
     Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
   if (!Values[3])
     Values[3] = llvm::Constant::getNullValue(
                   llvm::PointerType::getUnqual(ObjCTypes.ImpnfABITy));
   llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
                                                    Values);
-  llvm::GlobalVariable *GV = GetClassGlobal(ClassName, Weak);
+  llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(
+                               GetClassGlobal(ClassName,
+                                              /*ForDefinition=*/true,
+                                              Weak));
+  if (Init->getType() != GV->getValueType())
+    Init = llvm::ConstantExpr::getBitCast(Init, GV->getValueType());
   GV->setInitializer(Init);
   GV->setSection("__DATA, __objc_data");
   GV->setAlignment(
     CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
   if (HiddenVisibility)
     GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
   return GV;
 }
void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
   uint32_t InstanceStart =
     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
   uint32_t InstanceSize = InstanceStart;
   uint32_t flags = NonFragileABI_Class_Meta;
   llvm::SmallString<64> ObjCMetaClassName(getMetaclassSymbolPrefix());
   llvm::SmallString<64> ObjCClassName(getClassSymbolPrefix());
   llvm::SmallString<64> TClassName;
 
-  llvm::GlobalVariable *SuperClassGV, *IsAGV;
+  llvm::Constant *SuperClassGV, *IsAGV;
 
   // Build the flags for the metaclass.
   bool classIsHidden =
     ID->getClassInterface()->getVisibility() == HiddenVisibility;
   if (classIsHidden)
     flags |= NonFragileABI_Class_Hidden;
 
   // FIXME: why is this flag set on the metaclass?
   // ObjC metaclasses have no fields and don't really get constructed.
   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
     flags |= NonFragileABI_Class_HasCXXStructors;
     if (!ID->hasNonZeroConstructors())
       flags |= NonFragileABI_Class_HasCXXDestructorOnly;  
   }
 
   if (!ID->getClassInterface()->getSuperClass()) {
     // class is root
     flags |= NonFragileABI_Class_Root;
     TClassName = ObjCClassName;
     TClassName += ClassName;
     SuperClassGV = GetClassGlobal(TClassName.str(),
+                                  /*ForDefinition=*/false,
                                   ID->getClassInterface()->isWeakImported());
     TClassName = ObjCMetaClassName;
     TClassName += ClassName;
     IsAGV = GetClassGlobal(TClassName.str(),
+                           /*ForDefinition=*/false,
                            ID->getClassInterface()->isWeakImported());
   } else {
     // Has a root. Current class is not a root.
     const ObjCInterfaceDecl *Root = ID->getClassInterface();
     while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
       Root = Super;
     TClassName = ObjCMetaClassName ;
     TClassName += Root->getObjCRuntimeNameAsString();
     IsAGV = GetClassGlobal(TClassName.str(),
+                           /*ForDefinition=*/false,
                            Root->isWeakImported());
 
     // work on super class metadata symbol.
     TClassName = ObjCMetaClassName;
     TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
     SuperClassGV = GetClassGlobal(
                                   TClassName.str(),
+                                  /*ForDefinition=*/false,
                                   ID->getClassInterface()->getSuperClass()->isWeakImported());
   }
   llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
                                                                InstanceStart,
                                                                InstanceSize,ID);
   TClassName = ObjCMetaClassName;
   TClassName += ClassName;
   llvm::GlobalVariable *MetaTClass = BuildClassMetaData(
if (!ID->getClassInterface()->getSuperClass()) {
     flags |= NonFragileABI_Class_Root;
     SuperClassGV = nullptr;
   } else {
     // Has a root. Current class is not a root.
     TClassName = ObjCClassName;
     TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
     SuperClassGV = GetClassGlobal(
                                   TClassName.str(),
+                                  /*ForDefinition=*/false,
                                   ID->getClassInterface()->getSuperClass()->isWeakImported());
   }
   GetClassSizeInfo(ID, InstanceStart, InstanceSize);
   CLASS_RO_GV = BuildClassRoTInitializer(flags,
                                          InstanceStart,
                                          InstanceSize,
                                          ID);
 
void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
   ExtCatName += OCD->getNameAsString();
     
   llvm::SmallString<64> ExtClassName(getClassSymbolPrefix());
   ExtClassName += Interface->getObjCRuntimeNameAsString();
 
   llvm::Constant *Values[6];
   Values[0] = GetClassName(OCD->getIdentifier()->getName());
   // meta-class entry symbol
-  llvm::GlobalVariable *ClassGV =
-      GetClassGlobal(ExtClassName.str(), Interface->isWeakImported());
+  llvm::Constant *ClassGV = GetClassGlobal(ExtClassName.str(),
+                                           /*ForDefinition=*/false,
+                                           Interface->isWeakImported());
 
   Values[1] = ClassGV;
   std::vector<llvm::Constant*> Methods;
   llvm::SmallString<64> MethodListName(Prefix);
     
   MethodListName += "INSTANCE_METHODS_";
   MethodListName += Interface->getObjCRuntimeNameAsString();
   MethodListName += "_$_";
? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
                             Receiver, CGF.getContext().getObjCIdType(),
                             false, CallArgs, Method)
     : EmitMessageSend(CGF, Return, ResultType,
                       EmitSelector(CGF, Sel),
                       Receiver, CGF.getContext().getObjCIdType(),
                       false, CallArgs, Method, ObjCTypes);
 }
 
-llvm::GlobalVariable *
-CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name, bool Weak) {
+llvm::Constant *
+CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name,
+                                       bool ForDefinition,
+                                       bool Weak) {
   llvm::GlobalValue::LinkageTypes L =
       Weak ? llvm::GlobalValue::ExternalWeakLinkage
            : llvm::GlobalValue::ExternalLinkage;
 
   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
 
   if (!GV)
     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
                                   false, L, nullptr, Name);
 
   assert(GV->getLinkage() == L);
+
+  if (ForDefinition ||
+      GV->getValueType() == ObjCTypes.ClassnfABITy)
     return GV;
+
+  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ClassnfABIPtrTy);
 }
 
 llvm::Value *CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
                                                         IdentifierInfo *II,
                                                         bool Weak,
                                                         const ObjCInterfaceDecl *ID) {
   llvm::GlobalVariable *&Entry = ClassReferences[II];
   
   if (!Entry) {
     std::string ClassName(
       getClassSymbolPrefix() +
       (ID ? ID->getObjCRuntimeNameAsString() : II->getName()).str());
-    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName, Weak);
+    llvm::Constant *ClassGV = GetClassGlobal(ClassName,
+                                             /*ForDefinition=*/false,
+                                             Weak);
     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                      false, llvm::GlobalValue::PrivateLinkage,
                                      ClassGV, "OBJC_CLASSLIST_REFERENCES_$_");
     Entry->setAlignment(
                         CGM.getDataLayout().getABITypeAlignment(
                                                                 ObjCTypes.ClassnfABIPtrTy));
     Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
     CGM.addCompilerUsedGlobal(Entry);

 llvm::Value *
 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
                                           const ObjCInterfaceDecl *ID) {
   llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
 
   if (!Entry) {
     llvm::SmallString<64> ClassName(getClassSymbolPrefix());
     ClassName += ID->getObjCRuntimeNameAsString();
-    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(),
-                                                   ID->isWeakImported());
+    llvm::Constant *ClassGV = GetClassGlobal(ClassName.str(),
+                                             /*ForDefinition=*/false,
     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                      false, llvm::GlobalValue::PrivateLinkage,
                                      ClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
     Entry->setAlignment(
       CGM.getDataLayout().getABITypeAlignment(
         ObjCTypes.ClassnfABIPtrTy));
     Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
     CGM.addCompilerUsedGlobal(Entry);
   }
   return CGF.Builder.CreateLoad(Entry);
 }
 
 /// EmitMetaClassRef - Return a Value * of the address of _class_t
 /// meta-data
 ///
 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
                                                       const ObjCInterfaceDecl *ID,
                                                       bool Weak) {
   llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
   if (!Entry) {
     llvm::SmallString<64> MetaClassName(getMetaclassSymbolPrefix());
     MetaClassName += ID->getObjCRuntimeNameAsString();
-    llvm::GlobalVariable *MetaClassGV =
-      GetClassGlobal(MetaClassName.str(), Weak);
+    llvm::Constant *MetaClassGV = GetClassGlobal(MetaClassName.str(),
+                                                 /*ForDefinition=*/false,
+                                                 Weak);
 
     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                      false, llvm::GlobalValue::PrivateLinkage,
                                      MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
     Entry->setAlignment(
         CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABIPtrTy));
 
     Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
     CGM.addCompilerUsedGlobal(Entry);
   }
 
   return CGF.Builder.CreateLoad(Entry);
 }
 
 /// GetClass - Return a reference to the class for the given interface
 /// decl.
 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
                                               const ObjCInterfaceDecl *ID) {
   if (ID->isWeakImported()) {
     llvm::SmallString<64> ClassName(getClassSymbolPrefix());
     ClassName += ID->getObjCRuntimeNameAsString();
-    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(), true);
+    llvm::GlobalVariable *ClassGV = cast<llvm::GlobalVariable>(
+                                      GetClassGlobal(ClassName.str(),
+                                                     /*ForDefinition=*/true,
+                                                     /*Weak=*/true));
     (void)ClassGV;
     assert(ClassGV->hasExternalWeakLinkage());
   }
   
   return EmitClassRef(CGF, ID);
 }
 
 /// Generates a message send where the super is the receiver.  This is
CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
   if (!VTableGV)
     VTableGV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy,
                                         false,
                                         llvm::GlobalValue::ExternalLinkage,
                                         nullptr, VTableName);
 
   llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
 
+  llvm::Constant *ClassGV = GetClassGlobal(ClassName.str(),
+                                           /*ForDefinition=*/false,
+                                           /*Weak=*/false);
+
   llvm::Constant *Values[] = {
       llvm::ConstantExpr::getGetElementPtr(VTableGV->getValueType(), VTableGV,
                                            VTableIdx),
       GetClassName(ID->getObjCRuntimeNameAsString()),
-      GetClassGlobal(ClassName.str())};
+      ClassGV};
   llvm::Constant *Init =
     llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
 
   llvm::GlobalValue::LinkageTypes L = ForDefinition
                                           ? llvm::GlobalValue::ExternalLinkage
                                           : llvm::GlobalValue::WeakAnyLinkage;
   if (Entry) {
     Entry->setInitializer(Init);

lib/CodeGen/CGObjCRuntime.h

virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
                                         llvm::Value *SrcPtr,
                                         llvm::Value *Size) = 0;
   virtual llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
                                   const CodeGen::CGBlockInfo &blockInfo) = 0;
   virtual llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
                                   const CodeGen::CGBlockInfo &blockInfo) = 0;
   virtual llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                            QualType T) = 0;
-  virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
-                                               bool Weak = false) = 0;
+  virtual llvm::Constant *GetClassGlobal(const std::string &Name,
+                                         bool ForDefinition,
+                                         bool Weak) = 0;
 
   struct MessageSendInfo {
     const CGFunctionInfo &CallInfo;
     llvm::PointerType *MessengerType;
 
     MessageSendInfo(const CGFunctionInfo &callInfo,
                     llvm::PointerType *messengerType)
       : CallInfo(callInfo), MessengerType(messengerType) {}

lib/CodeGen/CodeGenModule.cpp

CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
   if (!ConstantStringClassRef) {
     std::string StringClass(getLangOpts().ObjCConstantStringClass);
     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
     llvm::Constant *GV;
     if (LangOpts.ObjCRuntime.isNonFragile()) {
       std::string str = 
         StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" 
                             : "OBJC_CLASS_$_" + StringClass;
-      GV = getObjCRuntime().GetClassGlobal(str);
+      GV = getObjCRuntime().GetClassGlobal(str,
+                                           /*ForDefinition=*/false,
+                                           /*Weak=*/false);
       // Make sure the result is of the correct type.
       llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
       V = llvm::ConstantExpr::getBitCast(GV, PTy);
       ConstantStringClassRef = V;
     } else {
       std::string str =
         StringClass.empty() ? "_NSConstantStringClassReference"
                             : "_" + StringClass + "ClassReference";