[embedded] Make embedded print() not depend on untyped throwing and allocations

Author: kubamracek

include/swift/Runtime/RuntimeFunctions.def

@@ -193,7 +193,7 @@ FUNCTION(UnexpectedError, swift_unexpectedError, SwiftCC, AlwaysAvailable,
          RETURNS(VoidTy),
          ARGS(ErrorPtrTy),
          ATTRS(NoUnwind, NoReturn),
-         EFFECT(NoEffect),
+         EFFECT(NoEffect, Deallocating),
          UNKNOWN_MEMEFFECTS)
 
 // void *swift_copyPOD(void *dest, void *src, Metadata *self);

stdlib/public/core/EmbeddedPrint.swift

@@ -59,26 +59,35 @@ extension BinaryInteger {
     }
     let isNegative = Self.isSigned && self < (0 as Self)
     var value = magnitude
-    withUnsafeTemporaryAllocation(byteCount: 64, alignment: 1) { buffer in
-      var index = buffer.count - 1
-      while value != 0 {
-        let (quotient, remainder) =
-            value.quotientAndRemainder(dividingBy: Magnitude(radix))
-        buffer[index] = _ascii(UInt8(truncatingIfNeeded: remainder))
-        index -= 1
-        value = quotient
-      }
-      if isNegative {
-        buffer[index] = UInt8(("-" as Unicode.Scalar).value)
-        index -= 1
-      }
-      let start = index + 1
-      let end = buffer.count - 1
-      let count = end - start + 1
 
-      let pointerToPrint = buffer.baseAddress?.advanced(by: start).assumingMemoryBound(to: UInt8.self)
-      printCharacters(UnsafeBufferPointer(start: pointerToPrint, count: count))
+    // Avoid withUnsafeTemporaryAllocation which is not typed-throws ready yet
+    let byteCount = 64
+    let stackBuffer = Builtin.stackAlloc(byteCount._builtinWordValue,
+         1._builtinWordValue, 1._builtinWordValue)
+    let buffer = UnsafeMutableRawBufferPointer(start: .init(stackBuffer),
+        count: byteCount)
+
+    var index = buffer.count - 1
+    while value != 0 {
+      let (quotient, remainder) =
+          value.quotientAndRemainder(dividingBy: Magnitude(radix))
+      buffer[index] = _ascii(UInt8(truncatingIfNeeded: remainder))
+      index -= 1
+      value = quotient
     }
+    if isNegative {
+      buffer[index] = UInt8(("-" as Unicode.Scalar).value)
+      index -= 1
+    }
+    let start = index + 1
+    let end = buffer.count - 1
+    let count = end - start + 1
+
+    let pointerToPrint = buffer.baseAddress?.advanced(by: start)
+        .assumingMemoryBound(to: UInt8.self)
+    printCharacters(UnsafeBufferPointer(start: pointerToPrint, count: count))
+
+    Builtin.stackDealloc(stackBuffer)
   }
 }
 

stdlib/public/core/LifetimeManager.swift

@@ -99,6 +99,7 @@ public func _withUnprotectedUnsafeMutablePointer<T, Result>(
 #endif
 }
 
+#if !$Embedded
 /// Invokes the given closure with a pointer to the given argument.
 ///
 /// The `withUnsafePointer(to:_:)` function is useful for calling Objective-C
@@ -127,6 +128,17 @@ public func withUnsafePointer<T, Result>(
 {
   return try body(UnsafePointer<T>(Builtin.addressOfBorrow(value)))
 }
+#else
+// TODO: This should be unified with non-embedded Swift.
+@inlinable
+public func withUnsafePointer<T, E, Result>(
+  to value: T,
+  _ body: (UnsafePointer<T>) throws(E) -> Result
+) throws(E) -> Result
+{
+  return try body(UnsafePointer<T>(Builtin.addressOfBorrow(value)))
+}
+#endif
 
 /// Invokes the given closure with a pointer to the given argument.
 ///