IRGen: fix and re-enable static read-only arrays

Static read-only arrays didn't work when passed to ObjectiveC as NSArray.
The storage class of static read-only arrays doesn't carry information about the Element type.
The new `__SwiftDeferredStaticNSArray` is generic over the element type and doesn't have to rely on the element type information of the array storage.

Author: eeckstein

lib/IRGen/GenConstant.cpp

@@ -294,7 +294,7 @@ llvm::Constant *irgen::emitConstantObject(IRGenModule &IGM, ObjectInst *OI,
       // deinit is a no-op and does not actually destroy any elements.
       auto *var = new llvm::GlobalVariable(IGM.Module, IGM.TypeMetadataStructTy,
                                         /*constant*/ true, llvm::GlobalValue::ExternalLinkage,
-                                        /*initializer*/ nullptr, "$ss19__EmptyArrayStorageCN");
+                                        /*initializer*/ nullptr, "$ss20__StaticArrayStorageCN");
       IGM.swiftStaticArrayMetadata = var;
     }
     elts[0] = llvm::ConstantStruct::get(ObjectHeaderTy, {

lib/IRGen/IRGenModule.cpp

@@ -1865,12 +1865,6 @@ bool IRGenModule::shouldPrespecializeGenericMetadata() {
 }
 
 bool IRGenModule::canMakeStaticObjectsReadOnly() {
-  // Unconditionally disable this until we can fix the metadata.
-  // The trick of using the Empty array metadata for static arrays
-  // breaks Obj-C interop quite badly.
-  // rdar://101126543
-  return false;
-
   if (getOptions().DisableReadonlyStaticObjects)
     return false;
 

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -62,6 +62,48 @@ internal final class __EmptyArrayStorage
   }
 }
 
+/// The storage for static read-only arrays.
+///
+/// In contrast to `_ContiguousArrayStorage` this class is _not_ generic over
+/// the element type, because the metatype for static read-only arrays cannot
+/// be instantiated at runtime.
+///
+/// Static read-only arrays can only contain non-verbatim bridged element types.
+@_fixed_layout
+@usableFromInline
+@_objc_non_lazy_realization
+internal final class __StaticArrayStorage
+  : __ContiguousArrayStorageBase {
+
+  @inlinable
+  @nonobjc
+  internal init(_doNotCallMe: ()) {
+    _internalInvariantFailure("creating instance of __StaticArrayStorage")
+  }
+
+#if _runtime(_ObjC)
+  override internal func _withVerbatimBridgedUnsafeBuffer<R>(
+    _ body: (UnsafeBufferPointer<AnyObject>) throws -> R
+  ) rethrows -> R? {
+    return nil
+  }
+
+  override internal func _getNonVerbatimBridgingBuffer() -> _BridgingBuffer {
+    fatalError("__StaticArrayStorage._withVerbatimBridgedUnsafeBuffer must not be called")
+  }
+#endif
+
+  @inlinable
+  override internal func canStoreElements(ofDynamicType _: Any.Type) -> Bool {
+    return false
+  }
+
+  @inlinable
+  override internal var staticElementType: Any.Type {
+    fatalError("__StaticArrayStorage.staticElementType must not be called")
+  }
+}
+
 /// The empty array prototype.  We use the same object for all empty
 /// `[Native]Array<Element>`s.
 @inlinable
@@ -827,6 +869,9 @@ internal struct _ContiguousArrayBuffer<Element>: _ArrayBufferProtocol {
       }
       return _storage
     }
+    if _storage is __StaticArrayStorage {
+      return __SwiftDeferredStaticNSArray<Element>(_nativeStorage: _storage)
+    }
     return __SwiftDeferredNSArray(_nativeStorage: _storage)
   }
 #endif

stdlib/public/core/SwiftNativeNSArray.swift

@@ -329,29 +329,29 @@ extension __SwiftNativeNSArrayWithContiguousStorage {
 /// buffers used for Array storage.
 @_fixed_layout // FIXME(sil-serialize-all)
 @usableFromInline
-@objc internal final class __SwiftDeferredNSArray
+@objc internal class __SwiftDeferredNSArray
   : __SwiftNativeNSArrayWithContiguousStorage {
 
   // This stored property should be stored at offset zero.  We perform atomic
   // operations on it.
   //
   // Do not access this property directly.
   @nonobjc
-  internal var _heapBufferBridged_DoNotUse: AnyObject?
+  internal final var _heapBufferBridged_DoNotUse: AnyObject?
 
   // When this class is allocated inline, this property can become a
   // computed one.
   @usableFromInline
   @nonobjc
-  internal let _nativeStorage: __ContiguousArrayStorageBase
+  internal final let _nativeStorage: __ContiguousArrayStorageBase
 
   @nonobjc
-  internal var _heapBufferBridgedPtr: UnsafeMutablePointer<AnyObject?> {
+  internal final var _heapBufferBridgedPtr: UnsafeMutablePointer<AnyObject?> {
     return _getUnsafePointerToStoredProperties(self).assumingMemoryBound(
       to: Optional<AnyObject>.self)
   }
 
-  internal var _heapBufferBridged: __BridgingBufferStorage? {
+  internal final var _heapBufferBridged: __BridgingBufferStorage? {
     if let ref =
       _stdlib_atomicLoadARCRef(object: _heapBufferBridgedPtr) {
       return unsafeBitCast(ref, to: __BridgingBufferStorage.self)
@@ -365,7 +365,7 @@ extension __SwiftNativeNSArrayWithContiguousStorage {
     self._nativeStorage = _nativeStorage
   }
 
-  internal func _destroyBridgedStorage(_ hb: __BridgingBufferStorage?) {
+  internal final func _destroyBridgedStorage(_ hb: __BridgingBufferStorage?) {
     if let bridgedStorage = hb {
       let buffer = _BridgingBuffer(bridgedStorage)
       let count = buffer.count
@@ -422,10 +422,70 @@ extension __SwiftNativeNSArrayWithContiguousStorage {
   /// This override allows the count to be read without triggering
   /// bridging of array elements.
   @objc
-  internal override var count: Int {
+  internal override final var count: Int {
     return _nativeStorage.countAndCapacity.count
   }
 }
+
+/// A `__SwiftDeferredNSArray` which is used for static read-only Swift Arrays.
+///
+/// In contrast to it's base class, `__SwiftDeferredStaticNSArray` is generic
+/// over the element type. This is needed because the storage class of a static
+/// read-only array does _not_ provide the element type.
+internal final class __SwiftDeferredStaticNSArray<Element>
+  : __SwiftDeferredNSArray {
+
+  internal override func withUnsafeBufferOfObjects<R>(
+    _ body: (UnsafeBufferPointer<AnyObject>) throws -> R
+  ) rethrows -> R {
+    while true {
+      var buffer: UnsafeBufferPointer<AnyObject>
+
+      // If we've already got a buffer of bridged objects, just use it
+      if let bridgedStorage = _heapBufferBridged {
+        let bridgingBuffer = _BridgingBuffer(bridgedStorage)
+        buffer = UnsafeBufferPointer(
+            start: bridgingBuffer.baseAddress, count: bridgingBuffer.count)
+      }
+      else {
+        // Static read-only arrays can only contain non-verbatim bridged
+        // element types.
+
+        // Create buffer of bridged objects.
+        let objects = getNonVerbatimBridgingBuffer()
+
+        // Atomically store a reference to that buffer in self.
+        if !_stdlib_atomicInitializeARCRef(
+          object: _heapBufferBridgedPtr, desired: objects.storage!) {
+
+          // Another thread won the race.  Throw out our buffer.
+          _destroyBridgedStorage(
+            unsafeDowncast(objects.storage!, to: __BridgingBufferStorage.self))
+        }
+        continue // Try again
+      }
+
+      defer { _fixLifetime(self) }
+      return try body(buffer)
+    }
+  }
+
+  internal func getNonVerbatimBridgingBuffer() -> _BridgingBuffer {
+    _internalInvariant(
+      !_isBridgedVerbatimToObjectiveC(Element.self),
+      "Verbatim bridging should be handled separately")
+    let count = _nativeStorage.countAndCapacity.count
+    let result = _BridgingBuffer(count)
+    let resultPtr = result.baseAddress
+    let p = UnsafeMutablePointer<Element>(Builtin.projectTailElems(_nativeStorage, Element.self))
+    for i in 0..<count {
+      (resultPtr + i).initialize(to: _bridgeAnythingToObjectiveC(p[i]))
+    }
+    _fixLifetime(self)
+    return result
+  }
+}
+
 #else
 // Empty shim version for non-objc platforms.
 @usableFromInline

test/SILOptimizer/readonly_arrays.swift

@@ -9,20 +9,19 @@
 
 // Check if the optimizer is able to convert array literals to constant statically initialized arrays.
 
-// CHECK: @"$s4test11arrayLookupyS2iFTv_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
-// CHECK: @"$s4test11returnArraySaySiGyFTv_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
-// CHECK: @"$s4test9passArrayyyFTv_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
-// CHECK: @"$s4test9passArrayyyFTv0_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
-// CHECK: @"$s4test10storeArrayyyFTv_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
-// CHECK: @"$s4test3StrV14staticVariable_WZTv_r" = {{.*}} constant {{.*}} @"$ss19__EmptyArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test11arrayLookupyS2iFTv_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test11returnArraySaySiGyFTv_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test9passArrayyyFTv_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test9passArrayyyFTv0_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test10storeArrayyyFTv_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
+// CHECK: @"$s4test3StrV14staticVariable_WZTv_r" = {{.*}} constant {{.*}} @"$ss20__StaticArrayStorageCN", {{.*}} @_swiftImmortalRefCount
 // CHECK-NOT: swift_initStaticObject
 
 // UNSUPPORTED: use_os_stdlib
 
 // Currently, constant static arrays only work on Darwin platforms.
 // REQUIRES: VENDOR=apple
 
-// REQUIRES: rdar101126543
 
 public struct Str {
   public static let staticVariable = [ 200, 201, 202 ]

test/SILOptimizer/readonly_arrays_objc.swift

@@ -0,0 +1,34 @@
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -target %target-future-triple -O %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test,swift_stdlib_no_asserts,optimized_stdlib
+// REQUIRES: objc_interop
+
+// UNSUPPORTED: use_os_stdlib
+
+import Foundation
+
+@inline(never)
+func createArray() -> [Int] {
+  return [1, 2, 3]
+}
+
+@inline(never)
+func printNSArray(_ a: NSArray) {
+  // CHECK: 1
+  print(a[0])
+  // CHECK: 2
+  print(a[1])
+  // CHECK: 3
+  print(a[2])
+}
+
+
+@inline(never)
+func testit() {
+  let a = createArray()
+  printNSArray(a as NSArray)
+}
+
+testit()