Merge pull request swiftlang#68658 from kubamracek/embedded-pointer-conversions

[embedded] Un-fatalError array to pointer conversion APIs, add test

Author: kubamracek

stdlib/public/core/Array.swift

@@ -1486,7 +1486,6 @@ extension Array: CustomStringConvertible, CustomDebugStringConvertible {
 
 extension Array {
   @usableFromInline @_transparent
-  @_unavailableInEmbedded
   internal func _cPointerArgs() -> (AnyObject?, UnsafeRawPointer?) {
     let p = _baseAddressIfContiguous
     if _fastPath(p != nil || isEmpty) {

stdlib/public/core/Pointer.swift

@@ -415,12 +415,12 @@ func _convertInOutToPointerArgument<
   return ToPointer(from)
 }
 
-#if !$Embedded
 
 /// Derive a pointer argument from a value array parameter.
 ///
 /// This always produces a non-null pointer, even if the array doesn't have any
 /// storage.
+#if !$Embedded
 @_transparent
 public // COMPILER_INTRINSIC
 func _convertConstArrayToPointerArgument<
@@ -439,10 +439,31 @@ func _convertConstArrayToPointerArgument<
   }
   return (owner, validPointer)
 }
+#else
+@_transparent
+public // COMPILER_INTRINSIC
+func _convertConstArrayToPointerArgument<
+  FromElement,
+  ToPointer: _Pointer
+>(_ arr: [FromElement]) -> (Builtin.NativeObject?, ToPointer) {
+  let (owner, opaquePointer) = arr._cPointerArgs()
+
+  let validPointer: ToPointer
+  if let addr = opaquePointer {
+    validPointer = ToPointer(addr._rawValue)
+  } else {
+    let lastAlignedValue = ~(MemoryLayout<FromElement>.alignment - 1)
+    let lastAlignedPointer = UnsafeRawPointer(bitPattern: lastAlignedValue)!
+    validPointer = ToPointer(lastAlignedPointer._rawValue)
+  }
+  return (owner, validPointer)
+}
+#endif
 
 /// Derive a pointer argument from an inout array parameter.
 ///
 /// This always produces a non-null pointer, even if the array's length is 0.
+#if !$Embedded
 @_transparent
 public // COMPILER_INTRINSIC
 func _convertMutableArrayToPointerArgument<
@@ -458,8 +479,26 @@ func _convertMutableArrayToPointerArgument<
 
   return _convertConstArrayToPointerArgument(a)
 }
+#else
+@_transparent
+public // COMPILER_INTRINSIC
+func _convertMutableArrayToPointerArgument<
+  FromElement,
+  ToPointer: _Pointer
+>(_ a: inout [FromElement]) -> (Builtin.NativeObject?, ToPointer) {
+  // TODO: Putting a canary at the end of the array in checked builds might
+  // be a good idea
+
+  // Call reserve to force contiguous storage.
+  a.reserveCapacity(0)
+  _debugPrecondition(a._baseAddressIfContiguous != nil || a.isEmpty)
+
+  return _convertConstArrayToPointerArgument(a)
+}
+#endif
 
 /// Derive a UTF-8 pointer argument from a value string parameter.
+#if !$Embedded
 @_transparent
 public // COMPILER_INTRINSIC
 func _convertConstStringToUTF8PointerArgument<
@@ -468,25 +507,12 @@ func _convertConstStringToUTF8PointerArgument<
   let utf8 = Array(str.utf8CString)
   return _convertConstArrayToPointerArgument(utf8)
 }
-
 #else
-
-@_unavailableInEmbedded public
-func _convertConstArrayToPointerArgument<FromElement,ToPointer: _Pointer>(
-    _ arr: [FromElement]) -> (Builtin.NativeObject?, ToPointer) {
-  fatalError("unreachable in embedded Swift (marked as unavailable)")
-}
-
-@_unavailableInEmbedded public
-func _convertMutableArrayToPointerArgument<FromElement, ToPointer: _Pointer>(
-    _ a: inout [FromElement]) -> (Builtin.NativeObject?, ToPointer) {
-  fatalError("unreachable in embedded Swift (marked as unavailable)")
-}
-
-@_unavailableInEmbedded public
+@_transparent
+@_unavailableInEmbedded
+public
 func _convertConstStringToUTF8PointerArgument<ToPointer: _Pointer>(
     _ str: String) -> (Builtin.NativeObject?, ToPointer) {
   fatalError("unreachable in embedded Swift (marked as unavailable)")
 }
-
 #endif

test/embedded/array-to-pointer.swift

@@ -0,0 +1,74 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -enable-experimental-feature Embedded -c -o %t/main.o
+// RUN: %target-clang -x c -c %S/Inputs/tiny-runtime-dummy-refcounting.c -o %t/runtime.o
+// RUN: %target-clang -x c -c %S/Inputs/print.c -o %t/print.o
+// RUN: %target-clang %t/main.o %t/runtime.o %t/print.o -o %t/a.out -dead_strip
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+@_silgen_name("putchar")
+func putchar(_: UInt8)
+
+public func print(_ s: StaticString, terminator: StaticString = "\n") {
+  var p = s.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+  p = terminator.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+}
+
+@_silgen_name("print_long")
+func print_long(_: Int)
+
+public func print(_ n: Int, terminator: StaticString = "\n") {
+    print_long(n)
+    print("", terminator: terminator)
+}
+
+func print(_ array: [Int]) {
+    print("[", terminator: "")
+    for i in 0 ..< array.count {
+        print_long(array[i])
+        if i != array.count - 1 { print(", ", terminator: "") }
+    }
+    print("]")
+}
+
+@_silgen_name("memcmp")
+func memcmp(_: UnsafeRawPointer, _: UnsafeRawPointer, _: Int) -> CInt
+
+@_silgen_name("memcpy")
+func memcpy(_: UnsafeMutableRawPointer, _: UnsafeRawPointer, _: Int) -> UnsafeRawPointer
+
+func test() {
+  print("Calling memcmp")
+  // CHECK: Calling memcmp
+
+  // const arrays
+  print(Int(memcmp([1, 2, 3], [1, 2, 3], MemoryLayout<Int>.size * 3)))
+  print(Int(memcmp([1, 2, 3], [1, 2, 4], MemoryLayout<Int>.size * 3)))
+  // CHECK-NEXT: 0
+  // CHECK-NEXT: 1
+
+  let a1 = [1, 2, 3]
+  let a2 = [1, 2, 4]
+  print(Int(memcmp(a1, a2, MemoryLayout<Int>.size * 3)))
+  // CHECK-NEXT: 1
+
+  // mutable array
+  var arr = [1, 2, 3, 4, 5]
+  var int42 = 42
+  memcpy(&arr, &int42, MemoryLayout<Int>.size)
+  print(arr)
+  // CHECK-NEXT: [42, 2, 3, 4, 5]
+}
+
+test()