[runtime] statically construct the Dictionary and Set singletons

Author: Alexis Beingessner

stdlib/public/SwiftShims/GlobalObjects.h

@@ -39,6 +39,44 @@ struct _SwiftEmptyArrayStorage {
 extern SWIFT_RUNTIME_STDLIB_INTERFACE
 struct _SwiftEmptyArrayStorage _swiftEmptyArrayStorage;
 
+struct _SwiftUnsafeBitMap {
+  __swift_uintptr_t *values;
+  __swift_intptr_t bitCount;
+};
+
+struct _SwiftDictionaryBodyStorage {
+  __swift_intptr_t capacity;
+  __swift_intptr_t count;
+  struct _SwiftUnsafeBitMap initializedEntries;
+  void *keys;
+  void *values;
+};
+
+struct _SwiftSetBodyStorage {
+  __swift_intptr_t capacity;
+  __swift_intptr_t count;
+  struct _SwiftUnsafeBitMap initializedEntries;
+  void *keys;
+};
+
+struct _SwiftEmptyDictionaryStorage {
+  struct HeapObject header;
+  struct _SwiftDictionaryBodyStorage body;
+  __swift_uintptr_t entries;
+};
+
+struct _SwiftEmptySetStorage {
+  struct HeapObject header;
+  struct _SwiftSetBodyStorage body;
+  __swift_uintptr_t entries;
+};
+
+extern SWIFT_RUNTIME_STDLIB_INTERFACE
+struct _SwiftEmptyDictionaryStorage _swiftEmptyDictionaryStorage;
+
+extern SWIFT_RUNTIME_STDLIB_INTERFACE
+struct _SwiftEmptySetStorage _swiftEmptySetStorage;
+
 struct _SwiftHashingSecretKey {
   __swift_uint64_t key0;
   __swift_uint64_t key1;

stdlib/public/core/HashedCollections.swift.gyb

@@ -2473,6 +2473,11 @@ collections = [
 /// keys, followed by the values.
 //
 // See the docs at the top of the file for more details on this type
+//
+// NOTE: The precise layout of this type is relied on in the runtime
+// to provide a statically allocated empty singleton. 
+// See stdlib/public/stubs/GlobalObjects.cpp for details.
+@objc_non_lazy_realization
 internal class _RawNative${Self}Storage:
   _SwiftNativeNS${Self}, _NS${Self}Core
 {
@@ -2496,31 +2501,10 @@ internal class _RawNative${Self}Storage:
   /// The empty singleton that is used for every single Dictionary that is
   /// created without any elements. The contents of the storage should never
   /// be mutated.
-  // FIXME: this should be set up in rodata like the Array singleton
-  internal static let empty: RawStorage = {
-    let storage = Builtin.allocWithTailElems_1(RawStorage.self,
-        1._builtinWordValue, UInt.self)
-    
-    // We set the capacity to 1 so that there's an empty hole to search.
-    // Any insertion will lead to a real storage being allocated, because 
-    // Dictionary guarantees there's always another empty hole after insertion.
-    storage.capacity = 1
-    storage.count = 0
-
-    // Initialize pointers to garbage; they should never be loaded
-    storage.keys  = UnsafeMutableRawPointer(bitPattern: 1)!
-  % if Self == 'Dictionary':
-    storage.values = UnsafeMutableRawPointer(bitPattern: 1)!
-  % end
-
-    let initializedEntries = _UnsafeBitMap(
-        storage: storage._initializedHashtableEntriesBitMapBuffer,
-        bitCount: 1)
-    initializedEntries.initializeToZero()
-
-    storage.initializedEntries = initializedEntries
-    return storage
-  }()
+  internal static var empty: RawStorage {
+    return Builtin.bridgeFromRawPointer(
+      Builtin.addressof(&_swiftEmpty${Self}Storage))
+  }
 
   // This type is made with allocWithTailElems, so no init is ever called.
   // But we still need to have an init to satisfy the compiler.

stdlib/public/stubs/GlobalObjects.cpp

@@ -26,6 +26,14 @@ namespace swift {
 // _direct type metadata for Swift._EmptyArrayStorage
 SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" ClassMetadata _TMCs18_EmptyArrayStorage;
+
+// _direct type metadata for Swift._RawNativeDictionaryStorage
+SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C" ClassMetadata _TMCs27_RawNativeDictionaryStorage;
+
+// _direct type metadata for Swift._RawNativeSetStorage
+SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C" ClassMetadata _TMCs20_RawNativeSetStorage;
 }
 
 swift::_SwiftEmptyArrayStorage swift::_swiftEmptyArrayStorage = {
@@ -41,6 +49,62 @@ swift::_SwiftEmptyArrayStorage swift::_swiftEmptyArrayStorage = {
   }
 };
 
+
+
+swift::_SwiftEmptyDictionaryStorage swift::_swiftEmptyDictionaryStorage = {
+  // HeapObject header;
+  {
+    &_TMCs27_RawNativeDictionaryStorage, // isa pointer
+  },
+  
+  // _SwiftDictionaryBodyStorage body;
+  {
+    // We set the capacity to 1 so that there's an empty hole to search.
+    // Any insertion will lead to a real storage being allocated, because 
+    // Dictionary guarantees there's always another empty hole after insertion.
+    1, // int capacity;                               
+    0, // int count;
+    
+    // _SwiftUnsafeBitMap initializedEntries
+    {
+      &swift::_swiftEmptyDictionaryStorage.entries, // unsigned int* values;
+      1 // int bitCount; (1 so there's something for iterators to read)
+    },
+    
+    (void*)1, // void* keys; (non-null garabage)
+    (void*)1  // void* values; (non-null garbage)
+  },
+
+  0 // int entries; (zero'd bits)
+};
+
+
+swift::_SwiftEmptySetStorage swift::_swiftEmptySetStorage = {
+  // HeapObject header;
+  {
+    &_TMCs20_RawNativeSetStorage, // isa pointer
+  },
+  
+  // _SwiftDictionaryBodyStorage body;
+  {
+    // We set the capacity to 1 so that there's an empty hole to search.
+    // Any insertion will lead to a real storage being allocated, because 
+    // Dictionary guarantees there's always another empty hole after insertion.
+    1, // int capacity;                                    
+    0, // int count;
+    
+    // _SwiftUnsafeBitMap initializedEntries
+    {
+      &swift::_swiftEmptySetStorage.entries, // unsigned int* values;
+      1 // int bitCount; (1 so there's something for iterators to read)
+    },
+    
+    (void*)1 // void* keys; (non-null garabage)
+  },
+
+  0 // int entries; (zero'd bits)
+};
+
 static __swift_uint64_t randomUInt64() {
 #if defined(__APPLE__)
   return static_cast<__swift_uint64_t>(arc4random()) |