Merge pull request #38452 from glessard/absurd-allocations-5.5

[5.5][runtime] Improve detection of memory allocation failures

Author: Kyle Macomber

include/swift/Basic/Malloc.h

@@ -34,11 +34,11 @@ inline void *AlignedAlloc(size_t size, size_t align) {
   if (align < sizeof(void*))
     align = sizeof(void*);
 
-  void *r;
 #if defined(_WIN32)
-  r = _aligned_malloc(size, align);
+  void *r = _aligned_malloc(size, align);
   assert(r && "_aligned_malloc failed");
 #else
+  void *r = nullptr;
   int res = posix_memalign(&r, align, size);
   assert(res == 0 && "posix_memalign failed");
   (void)res; // Silence the unused variable warning.

stdlib/public/core/UnsafeRawBufferPointer.swift.gyb

@@ -263,15 +263,21 @@ extension Unsafe${Mutable}RawBufferPointer: RandomAccessCollection { }
 
 extension Unsafe${Mutable}RawBufferPointer {
 %  if mutable:
-  /// Returns a newly allocated buffer with the given size, in bytes.
+  /// Allocates uninitialized memory with the specified size and alignment.
   ///
-  /// The memory referenced by the new buffer is allocated, but not
-  /// initialized.
+  /// You are in charge of managing the allocated memory. Be sure to deallocate
+  /// any memory that you manually allocate.
+  ///
+  /// The allocated memory is not bound to any specific type and must be bound
+  /// before performing any typed operations. If you are using the memory for
+  /// a specific type, allocate memory using the
+  /// `UnsafeMutablePointerBuffer.allocate(capacity:)` static method instead.
   ///
   /// - Parameters:
-  ///   - byteCount: The number of bytes to allocate.
+  ///   - byteCount: The number of bytes to allocate. `byteCount` must not be
+  ///     negative.
   ///   - alignment: The alignment of the new region of allocated memory, in
-  ///     bytes.
+  ///     bytes. `alignment` must be a whole power of 2.
   /// - Returns: A buffer pointer to a newly allocated region of memory aligned 
   ///     to `alignment`.
   @inlinable

stdlib/public/core/UnsafeRawPointer.swift

@@ -600,7 +600,7 @@ public struct UnsafeMutableRawPointer: _Pointer, Sendable {
   /// - Parameters:
   ///   - byteCount: The number of bytes to allocate. `byteCount` must not be negative.
   ///   - alignment: The alignment of the new region of allocated memory, in
-  ///     bytes.
+  ///     bytes. `alignment` must be a whole power of 2.
   /// - Returns: A pointer to a newly allocated region of memory. The memory is
   ///   allocated, but not initialized.
   @inlinable

test/stdlib/UnsafeRawPointer.swift

@@ -229,4 +229,18 @@ UnsafeMutableRawPointerExtraTestSuite.test("moveInitialize:from:") {
   check(Check.RightOverlap)
 }
 
+UnsafeMutableRawPointerExtraTestSuite.test("absurd.allocation.misaligned") {
+  expectCrashLater()
+  let mustFail = UnsafeMutableRawPointer.allocate(byteCount: 1024,
+                                                  alignment: 19)
+  expectUnreachable()
+}
+
+UnsafeMutableRawPointerExtraTestSuite.test("absurd.allocation.gargantuan") {
+  expectCrashLater()
+  let mustFail = UnsafeMutableRawPointer.allocate(byteCount: Int.max,
+                                                  alignment: 0)
+  expectUnreachable()
+}
+
 runAllTests()