Fix the code pattern with which we access ObjC classes to correctly

rjmccall · rjmccall · commit 7097facbd487 · 2016-04-06T21:53:02.000-07:00
use classrefs instead of accessing the symbol directly.

This might be a very nasty bug to work around.
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -1102,6 +1102,9 @@ SILLinkage LinkEntity::getLinkage(IRGenModule &IGM,
     }
     llvm_unreachable("bad metadata access kind");
 
+  case Kind::ObjCClassRef:
+    return SILLinkage::Private;
+
   case Kind::WitnessTableOffset:
   case Kind::Function:
   case Kind::Other:
@@ -1183,6 +1186,7 @@ bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
   case Kind::DirectProtocolWitnessTable:
     return ::isAvailableExternally(IGM, getProtocolConformance()->getDeclContext());
 
+  case Kind::ObjCClassRef:
   case Kind::TypeMangling:
   case Kind::ValueWitness:
   case Kind::WitnessTableOffset:
@@ -2210,6 +2214,33 @@ llvm::Constant *IRGenModule::emitTypeMetadataRecords() {
   return var;
 }
 
+/// Fetch a global reference to a reference to the given Objective-C class.
+/// The result is of type ObjCClassPtrTy->getPointerTo().
+Address IRGenModule::getAddrOfObjCClassRef(ClassDecl *theClass) {
+  assert(ObjCInterop && "getting address of ObjC class ref in no-interop mode");
+
+  Alignment alignment = getPointerAlignment();
+
+  LinkEntity entity = LinkEntity::forObjCClassRef(theClass);
+  DebugTypeInfo DbgTy(theClass, ObjCClassPtrTy->getPointerTo(),
+                      getPointerSize(), alignment);
+  auto addr = getAddrOfLLVMVariable(entity, alignment, NotForDefinition,
+                                    ObjCClassPtrTy, DbgTy);
+
+  // Define it lazily.
+  if (auto global = dyn_cast<llvm::GlobalVariable>(addr)) {
+    if (global->isDeclaration()) {
+      global->setSection("__DATA,__objc_classrefs,regular,no_dead_strip");
+      global->setLinkage(llvm::GlobalVariable::PrivateLinkage);
+      global->setExternallyInitialized(true);
+      global->setInitializer(getAddrOfObjCClass(theClass, NotForDefinition));
+      addCompilerUsedGlobal(global);
+    }
+  }
+
+  return Address(addr, alignment);
+}
+
 /// Fetch a global reference to the given Objective-C class.  The
 /// result is of type ObjCClassPtrTy.
 llvm::Constant *IRGenModule::getAddrOfObjCClass(ClassDecl *theClass,
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -301,7 +301,8 @@ llvm::Value *irgen::emitObjCHeapMetadataRef(IRGenFunction &IGF,
     return IGF.Builder.CreateCall(IGF.IGM.getLookUpClassFn(), className);
   }
 
-  auto classObject = IGF.IGM.getAddrOfObjCClass(theClass, NotForDefinition);
+  Address classRef = IGF.IGM.getAddrOfObjCClassRef(theClass);
+  auto classObject = IGF.Builder.CreateLoad(classRef);
   if (allowUninitialized) return classObject;
 
   // TODO: memoize this the same way that we memoize Swift type metadata?
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -839,6 +839,7 @@ private:                            \
                                               llvm::Type *definitionType);
   llvm::Constant *getAddrOfObjCClass(ClassDecl *D,
                                      ForDefinition_t forDefinition);
+  Address getAddrOfObjCClassRef(ClassDecl *D);
   llvm::Constant *getAddrOfObjCMetaclass(ClassDecl *D,
                                          ForDefinition_t forDefinition);
   llvm::Constant *getAddrOfSwiftMetaclassStub(ClassDecl *D,
diff --git a/lib/IRGen/Linking.cpp b/lib/IRGen/Linking.cpp
@@ -274,6 +274,16 @@ void LinkEntity::mangle(raw_ostream &buffer) const {
     }
       return mangler.finalize(buffer);
 
+  // An Objective-C class reference reference. The symbol is private, so
+  // the mangling is unimportant; it should just be readable in LLVM IR.
+  case Kind::ObjCClassRef: {
+    mangler.append("OBJC_CLASS_REF_$_");
+    llvm::SmallString<64> tempBuffer;
+    StringRef name = cast<ClassDecl>(getDecl())->getObjCRuntimeName(tempBuffer);
+    mangler.append(name);
+    return mangler.finalize(buffer);
+  }
+
   // An Objective-C class reference;  not a swift mangling.
   case Kind::ObjCClass: {
     llvm::SmallString<64> TempBuffer;
diff --git a/lib/IRGen/Linking.h b/lib/IRGen/Linking.h
@@ -104,6 +104,9 @@ class LinkEntity {
     /// An Objective-C class reference.  The pointer is a ClassDecl*.
     ObjCClass,
 
+    /// An Objective-C class reference reference.  The pointer is a ClassDecl*.
+    ObjCClassRef,
+
     /// An Objective-C metaclass reference.  The pointer is a ClassDecl*.
     ObjCMetaclass,
 
@@ -320,6 +323,12 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forObjCClassRef(ClassDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::ObjCClassRef, decl, 0);
+    return entity;
+  }
+
   static LinkEntity forObjCClass(ClassDecl *decl) {
     LinkEntity entity;
     entity.setForDecl(Kind::ObjCClass, decl, 0);
diff --git a/test/ClangModules/attr-swift_private.swift b/test/ClangModules/attr-swift_private.swift
@@ -89,7 +89,7 @@ public func testTopLevel() {
 }
 
 // CHECK-LABEL: define linkonce_odr hidden %swift.type* @_TMaCSo12__PrivFooSub{{.*}} {
-// CHECK: %objc_class* @"OBJC_CLASS_$_PrivFooSub"
+// CHECK: %objc_class** @"OBJC_CLASS_REF_$_PrivFooSub"
 // CHECK: }
 
 // CHECK-LABEL: define linkonce_odr hidden {{.+}} @_TTOFCSo3BarcfT2__Vs5Int32_GSQS__
diff --git a/test/ClangModules/objc_ir.swift b/test/ClangModules/objc_ir.swift
@@ -80,7 +80,8 @@ func propertyAccess(b b: B) {
 
 // CHECK: define hidden [[B]]* @_TF7objc_ir8downcastFT1aCSo1A_CSo1B(
 func downcast(a a: A) -> B {
-  // CHECK: [[T0:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_B")
+  // CHECK: [[CLASS:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_B"
+  // CHECK: [[T0:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[CLASS]])
   // CHECK: [[T1:%.*]] = bitcast %objc_class* [[T0]] to i8*
   // CHECK: call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[A:%.*]], i8* [[T1]]) [[NOUNWIND:#[0-9]+]]
   return a as! B
diff --git a/test/IRGen/generic_types.swift b/test/IRGen/generic_types.swift
@@ -87,7 +87,8 @@ import Swift
 // CHECK:   [[T0:%.*]] = bitcast i8** %1 to %swift.type**
 // CHECK:   %T = load %swift.type*, %swift.type** [[T0]],
 // CHECK-native: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* null)
-// CHECK-objc:   [[SUPER:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_SwiftObject")
+// CHECK-objc:   [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_SwiftObject"
+// CHECK-objc:   [[SUPER:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
 // CHECK-objc:   [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* [[SUPER]])
 // CHECK:   [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
 // CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i32 10
@@ -100,7 +101,8 @@ import Swift
 // CHECK:   [[T0:%.*]] = bitcast i8** %1 to %swift.type**
 // CHECK:   %T = load %swift.type*, %swift.type** [[T0]],
 // CHECK-native: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* null)
-// CHECK-objc:   [[SUPER:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_SwiftObject")
+// CHECK-objc:   [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_SwiftObject"
+// CHECK-objc:   [[SUPER:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
 // CHECK-objc:   [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* [[SUPER]])
 // CHECK:   [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
 // CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i32 10
diff --git a/test/IRGen/objc_casts.sil b/test/IRGen/objc_casts.sil
@@ -28,7 +28,8 @@ bb0(%unused : $@thick T.Type, %obj : $NSObject):
 // CHECK:       [[T0:%.*]] = call %objc_object* @swift_dynamicCastMetatypeToObjectUnconditional(%swift.type* %0)
 //   TODO: is this really necessary? also, this really shouldn't use a direct reference
 // CHECK-NEXT:  [[T1:%.*]] = bitcast %objc_object* [[T0]] to i8*
-// CHECK-NEXT:  [[T2:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_Foo")
+// CHECK-NEXT:  [[T2a:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_Foo"
+// CHECK-NEXT:  [[T2:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T2a]])
 // CHECK-NEXT:  [[T3:%.*]] = bitcast %objc_class* [[T2]] to i8*
 // CHECK-NEXT:  call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[T1]], i8* [[T3]])
 sil hidden @metatype_to_objc_class : $@convention(thin) <T> (@thick T.Type) -> () {
@@ -43,7 +44,8 @@ bb0(%metatype : $@thick T.Type):
 // CHECK:       [[T0:%.*]] = call %objc_object* @swift_dynamicCastMetatypeToObjectUnconditional(%swift.type* [[ARG]])
 //   TODO: is this really necessary? also, this really shouldn't use a direct reference
 // CHECK-NEXT:  [[T1:%.*]] = bitcast %objc_object* [[T0]] to i8*
-// CHECK-NEXT:  [[T2:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_Foo")
+// CHECK-NEXT:  [[T2a:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_Foo"
+// CHECK-NEXT:  [[T2:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T2a]])
 // CHECK-NEXT:  [[T3:%.*]] = bitcast %objc_class* [[T2]] to i8*
 // CHECK-NEXT:  call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[T1]], i8* [[T3]])
 sil hidden @opt_metatype_to_objc_class : $@convention(thin) <T> (Optional<T.Type>) -> () {
diff --git a/test/IRGen/objc_generic_class_metadata.sil b/test/IRGen/objc_generic_class_metadata.sil
@@ -28,7 +28,8 @@ entry:
   %b = metatype $@thick GenericClass<NSObject>.Type
   apply %z<GenericClass<NSObject>>(%b) : $@convention(thin) <T> (@thick T.Type) -> ()
 
-  // CHECK: [[OBJC_CLASS:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_GenericClass")
+  // CHECK: [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_GenericClass",
+  // CHECK: [[OBJC_CLASS:%.*]] = call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
   // CHECK: call void @objc_class_sink(%objc_class* [[OBJC_CLASS]], %swift.type* [[METADATA]])
   %c = metatype $@objc_metatype GenericClass<NSString>.Type
   apply %y<GenericClass<NSString>>(%c) : $@convention(thin) <T: AnyObject> (@objc_metatype T.Type) -> ()
@@ -46,7 +47,8 @@ entry:
 }
 
 // CHECK-LABEL: define linkonce_odr hidden %swift.type* @_TMaCSo12GenericClass()
-// CHECK:         call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* @"OBJC_CLASS_$_GenericClass")
+// CHECK:         [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_GenericClass",
+// CHECK:         call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
 
 // CHECK-LABEL: define linkonce_odr hidden %swift.type* @_TMaGSaTCSo12GenericClassSi__()
 // CHECK:         [[TUPLE:%.*]] = call %swift.type* @_TMaTCSo12GenericClassSi_()

Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,8 @@ llvm::Value *irgen::emitObjCHeapMetadataRef(IRGenFunction &IGF,`
`301`	`301`	`return IGF.Builder.CreateCall(IGF.IGM.getLookUpClassFn(), className);`
`302`	`302`	`}`
`303`	`303`
`304`		`- auto classObject = IGF.IGM.getAddrOfObjCClass(theClass, NotForDefinition);`
	`304`	`+ Address classRef = IGF.IGM.getAddrOfObjCClassRef(theClass);`
	`305`	`+ auto classObject = IGF.Builder.CreateLoad(classRef);`
`305`	`306`	`if (allowUninitialized) return classObject;`
`306`	`307`
`307`	`308`	`// TODO: memoize this the same way that we memoize Swift type metadata?`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public func testTopLevel() {`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`// CHECK-LABEL: define linkonce_odr hidden %swift.type* @_TMaCSo12__PrivFooSub{{.*}} {`
`92`		`-// CHECK: %objc_class* @"OBJC_CLASS_$_PrivFooSub"`
	`92`	`+// CHECK: %objc_class** @"OBJC_CLASS_REF_$_PrivFooSub"`
`93`	`93`	`// CHECK: }`
`94`	`94`
`95`	`95`	`// CHECK-LABEL: define linkonce_odr hidden {{.+}} @_TTOFCSo3BarcfT2__Vs5Int32_GSQS__`