Switch to malloc_good_size instead of malloc_size (#70532)

Switch to malloc_good_size instead of malloc_size

Author: Catfish-Man

stdlib/public/SwiftShims/swift/shims/LibcShims.h

@@ -129,6 +129,15 @@ static inline __swift_bool _swift_stdlib_has_malloc_size() {
   return HAS_MALLOC_SIZE != 0;
 }
 
+static inline __swift_size_t _swift_stdlib_malloc_good_size(__swift_size_t sz) {
+#if defined(__APPLE__)
+  extern __swift_size_t malloc_good_size(__swift_size_t);
+  return malloc_good_size(sz);
+#else
+  return (sz + 15) & ~15; //round up to the nearest 16 byte alignment, at least
+#endif
+}
+
 // Math library functions
 static inline SWIFT_ALWAYS_INLINE
 float _stdlib_remainderf(float _self, float _other) {

stdlib/public/core/Shims.swift

@@ -41,3 +41,31 @@ internal let _fastEnumerationStorageMutationsPtr =
 internal func _mallocSize(ofAllocation ptr: UnsafeRawPointer) -> Int? {
   return _swift_stdlib_has_malloc_size() ? _swift_stdlib_malloc_size(ptr) : nil
 }
+
+/*
+ Invariant:
+ malloc_size(malloc(malloc_good_size(size))) >= malloc_good_size(size)
+ 
+ Usually:
+ malloc_size(malloc(malloc_good_size(size))) == malloc_good_size(size)
+ */
+@_effects(readnone) @inline(__always)
+internal func _mallocGoodSize(for size: Int) -> Int {
+  precondition(size >= 0)
+  // Not all allocators will see benefits from rounding up to 16/32 byte aligned
+  // but it'll never cause misbehavior, and many reasonable ones will benefit
+  if (size <= 128) {
+    return (size &+ 15) & ~15;
+  }
+  if (size <= 256) {
+    return (size &+ 31) & ~31;
+  }
+  return _mallocGoodSizeLarge(for: size)
+}
+
+@_effects(readnone)
+internal func _mallocGoodSizeLarge(for size: Int) -> Int {
+  let goodSize = _swift_stdlib_malloc_good_size(size)
+  precondition(goodSize >= size)
+  return goodSize
+}

stdlib/public/core/StringStorage.swift

@@ -181,14 +181,12 @@ fileprivate func _allocate<T: AnyObject>(
 ) -> (T, realNumTailBytes: Int) {
   _internalInvariant(getSwiftClassInstanceExtents(T.self).1 == numHeaderBytes)
 
-  func roundUp(_ x: Int) -> Int { (x + 15) & ~15 }
-
   let numBytes = numHeaderBytes + numTailBytes
 
   let linearBucketThreshold = 128
   if _fastPath(numBytes < linearBucketThreshold) {
     // Allocate up to the nearest bucket of 16
-    let realNumBytes = roundUp(numBytes)
+    let realNumBytes = _mallocGoodSize(for: numBytes)
     let realNumTailBytes = realNumBytes - numHeaderBytes
     _internalInvariant(realNumTailBytes >= numTailBytes)
     let object = tailAllocator(realNumTailBytes)
@@ -202,21 +200,10 @@ fileprivate func _allocate<T: AnyObject>(
     growTailBytes = numTailBytes
   }
 
-  let total = roundUp(numHeaderBytes + growTailBytes)
+  let total = _mallocGoodSize(for: numHeaderBytes + growTailBytes)
   let totalTailBytes = total - numHeaderBytes
 
-  let object = tailAllocator(totalTailBytes)
-  if let allocSize = _mallocSize(ofAllocation:
-    UnsafeRawPointer(Builtin.bridgeToRawPointer(object))) {
-    _internalInvariant(allocSize % MemoryLayout<Int>.stride == 0)
-
-    let realNumTailBytes = allocSize - numHeaderBytes
-    _internalInvariant(realNumTailBytes >= numTailBytes)
-
-    return (object, realNumTailBytes)
-  } else {
-    return (object, totalTailBytes)
-  }
+  return (tailAllocator(totalTailBytes), totalTailBytes)
 }
 
 fileprivate func _allocateStringStorage(