stdlib: Dictionary: abstract away some of the address calculations in _roundUp()

Author: gribozavr

stdlib/public/core/Builtin.swift

@@ -61,17 +61,45 @@ public func strideofValue<T>(_:T) -> Int {
   return strideof(T.self)
 }
 
+// This function is the implementation of the `_roundUp` overload set.  It is
+// marked `@inline(__always)` to make primary `_roundUp` entry points seem
+// cheap enough for the inliner.
 @_versioned
-internal func _roundUp(_ offset: Int, toAlignment alignment: Int) -> Int {
-  _sanityCheck(offset >= 0)
+@inline(__always)
+internal func _roundUpImpl(_ offset: UInt, toAlignment alignment: Int) -> UInt {
   _sanityCheck(alignment > 0)
   _sanityCheck(_isPowerOf2(alignment))
   // Note, given that offset is >= 0, and alignment > 0, we don't
   // need to underflow check the -1, as it can never underflow.
-  let x = (offset + alignment &- 1)
+  let x = offset + UInt(bitPattern: alignment) &- 1
   // Note, as alignment is a power of 2, we'll use masking to efficiently
   // get the aligned value
-  return x & ~(alignment &- 1)
+  return x & ~(UInt(bitPattern: alignment) &- 1)
+}
+
+@_versioned
+internal func _roundUp(_ offset: UInt, toAlignment alignment: Int) -> UInt {
+  return _roundUpImpl(offset, toAlignment: alignment)
+}
+
+@_versioned
+internal func _roundUp(_ offset: Int, toAlignment alignment: Int) -> Int {
+  _sanityCheck(offset >= 0)
+  return Int(_roundUpImpl(UInt(bitPattern: offset), toAlignment: alignment))
+}
+
+@_versioned
+internal func _roundUp<T, DestinationType>(
+  _ pointer: UnsafeMutablePointer<T>,
+  toAlignmentOf destinationType: DestinationType.Type
+) -> UnsafeMutablePointer<DestinationType> {
+  // Note: unsafe unwrap is safe because this operation can only increase the
+  // value, and can not produce a null pointer.
+  return UnsafeMutablePointer<DestinationType>(
+    bitPattern: _roundUpImpl(
+      UInt(bitPattern: pointer),
+      toAlignment: alignof(DestinationType))
+  ).unsafelyUnwrapped
 }
 
 /// Returns a tri-state of 0 = no, 1 = yes, 2 = maybe.

stdlib/public/core/FixedPoint.swift.gyb

@@ -701,6 +701,14 @@ internal func _unsafeMinus(_ lhs: Int, _ rhs: Int) -> Int {
 #endif
 }
 
+internal func _unsafeMultiply(_ lhs: Int, _ rhs: Int) -> Int {
+#if INTERNAL_CHECKS_ENABLED
+  return lhs * rhs
+#else
+  return lhs &* rhs
+#endif
+}
+
 @available(*, unavailable, renamed: "Integer")
 public typealias IntegerType = Integer
 

stdlib/public/core/HashedCollections.swift.gyb

@@ -2605,38 +2605,23 @@ final internal class _Native${Self}StorageImpl<${TypeParameters}> :
 
   internal
   var _initializedHashtableEntriesBitMapStorage: UnsafeMutablePointer<UInt> {
-    get {
-      let start = UInt(Builtin.ptrtoint_Word(buffer._elementPointer._rawValue))
-      let alignment = UInt(alignof(UInt))
-      let alignMask = alignment &- UInt(1)
-      return UnsafeMutablePointer<UInt>(
-          bitPattern:(start &+ alignMask) & ~alignMask)!
-    }
+    return _roundUp(buffer._elementPointer, toAlignmentOf: UInt.self)
   }
 
   internal var _keys: UnsafeMutablePointer<Key> {
-    get {
-      let start =
-          UInt(Builtin.ptrtoint_Word(
-              _initializedHashtableEntriesBitMapStorage._rawValue)) &+
-          UInt(_BitMap.wordsFor(_capacity)) &* UInt(strideof(UInt))
-      let alignment = UInt(alignof(Key))
-      let alignMask = alignment &- UInt(1)
-      return UnsafeMutablePointer<Key>(
-          bitPattern:(start &+ alignMask) & ~alignMask)!
-    }
+    let bitMapSizeInBytes =
+      _unsafeMultiply(_BitMap.wordsFor(_capacity), strideof(UInt))
+    let start =
+      UnsafeMutablePointer<UInt8>(_initializedHashtableEntriesBitMapStorage)
+      + bitMapSizeInBytes
+    return _roundUp(start, toAlignmentOf: Key.self)
   }
 
 %if Self == 'Dictionary':
   internal var _values: UnsafeMutablePointer<Value> {
-    get {
-      let start = UInt(Builtin.ptrtoint_Word(_keys._rawValue)) &+
-        UInt(_capacity) &* UInt(strideof(Key.self))
-      let alignment = UInt(alignof(Value))
-      let alignMask = alignment &- UInt(1)
-      return UnsafeMutablePointer<Value>(
-          bitPattern:(start &+ alignMask) & ~alignMask)!
-    }
+    let keysSizeInBytes = _unsafeMultiply(_capacity, strideof(Key.self))
+    let start = UnsafeMutablePointer<UInt8>(_keys) + keysSizeInBytes
+    return _roundUp(start, toAlignmentOf: Value.self)
   }
 %end