Merge pull request #71789 from apple/revert-70532-david/asking-the-right-questions

Revert "Switch to malloc_good_size instead of malloc_size"

Author: jckarter

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

@@ -129,15 +129,6 @@ 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,31 +41,3 @@ 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,12 +181,14 @@ 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 = _mallocGoodSize(for: numBytes)
+    let realNumBytes = roundUp(numBytes)
     let realNumTailBytes = realNumBytes - numHeaderBytes
     _internalInvariant(realNumTailBytes >= numTailBytes)
     let object = tailAllocator(realNumTailBytes)
@@ -200,10 +202,21 @@ fileprivate func _allocate<T: AnyObject>(
     growTailBytes = numTailBytes
   }
 
-  let total = _mallocGoodSize(for: numHeaderBytes + growTailBytes)
+  let total = roundUp(numHeaderBytes + growTailBytes)
   let totalTailBytes = total - numHeaderBytes
 
-  return (tailAllocator(totalTailBytes), totalTailBytes)
+  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)
+  }
 }
 
 fileprivate func _allocateStringStorage(