stdlib: add underscored "withUnprotected..Pointer" functions

Those functions work the same way as their "unprotected" counterparts, except that they don't trigger stack protection for the pointers.

* `_withUnprotectedUnsafeMutablePointer`
* `_withUnprotectedUnsafePointer`
* `_withUnprotectedUnsafeBytes` (two times)

Author: eeckstein

stdlib/public/core/LifetimeManager.swift

@@ -82,6 +82,19 @@ public func withUnsafeMutablePointer<T, Result>(
   return try body(UnsafeMutablePointer<T>(Builtin.addressof(&value)))
 }
 
+/// Calls the given closure with a mutable pointer to the given argument.
+///
+/// This function is similar to `withUnsafeMutablePointer`, except that it
+/// doesn't trigger stack protection for the pointer.
+@_alwaysEmitIntoClient
+public func _withUnprotectedUnsafeMutablePointer<T, Result>(
+  to value: inout T,
+  _ body: (UnsafeMutablePointer<T>) throws -> Result
+) rethrows -> Result
+{
+  return try body(UnsafeMutablePointer<T>(Builtin.unprotectedAddressOf(&value)))
+}
+
 /// Invokes the given closure with a pointer to the given argument.
 ///
 /// The `withUnsafePointer(to:_:)` function is useful for calling Objective-C
@@ -144,6 +157,19 @@ public func withUnsafePointer<T, Result>(
   return try body(UnsafePointer<T>(Builtin.addressof(&value)))
 }
 
+/// Invokes the given closure with a pointer to the given argument.
+///
+/// This function is similar to `withUnsafePointer`, except that it
+/// doesn't trigger stack protection for the pointer.
+@_alwaysEmitIntoClient
+public func _withUnprotectedUnsafePointer<T, Result>(
+  to value: inout T,
+  _ body: (UnsafePointer<T>) throws -> Result
+) rethrows -> Result
+{
+  return try body(UnsafePointer<T>(Builtin.unprotectedAddressOf(&value)))
+}
+
 extension String {
   /// Calls the given closure with a pointer to the contents of the string,
   /// represented as a null-terminated sequence of UTF-8 code units.

stdlib/public/core/UnsafeRawBufferPointer.swift.gyb

@@ -1037,6 +1037,22 @@ public func withUnsafeBytes<T, Result>(
   }
 }
 
+/// Invokes the given closure with a buffer pointer covering the raw bytes of
+/// the given argument.
+///
+/// This function is similar to `withUnsafeBytes`, except that it
+/// doesn't trigger stack protection for the pointer.
+@_alwaysEmitIntoClient
+public func _withUnprotectedUnsafeBytes<T, Result>(
+  of value: inout T,
+  _ body: (UnsafeRawBufferPointer) throws -> Result
+) rethrows -> Result
+{
+  return try _withUnprotectedUnsafePointer(to: &value) {
+    try body(UnsafeRawBufferPointer(start: $0, count: MemoryLayout<T>.size))
+  }
+}
+
 /// Invokes the given closure with a buffer pointer covering the raw bytes of
 /// the given argument.
 ///
@@ -1066,6 +1082,21 @@ public func withUnsafeBytes<T, Result>(
   return try body(buffer)
 }
 
+/// Invokes the given closure with a buffer pointer covering the raw bytes of
+/// the given argument.
+///
+/// This function is similar to `withUnsafeBytes`, except that it
+/// doesn't trigger stack protection for the pointer.
+@_alwaysEmitIntoClient
+public func _withUnprotectedUnsafeBytes<T, Result>(
+  of value: T,
+  _ body: (UnsafeRawBufferPointer) throws -> Result
+) rethrows -> Result {
+  let addr = UnsafeRawPointer(Builtin.unprotectedAddressOfBorrow(value))
+  let buffer = UnsafeRawBufferPointer(start: addr, count: MemoryLayout<T>.size)
+  return try body(buffer)
+}
+
 // ${'Local Variables'}:
 // eval: (read-only-mode 1)
 // End: