Merge pull request swiftlang#76658 from kubamracek/embedded-managed-buffer

kubamracek · web-flow · commit d3c514971422 · 2024-09-25T02:54:55.000-07:00
[embedded] Add support for ManagedBuffer to Embedded Swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt b/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt
@@ -7,6 +7,7 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
+  SimplifyAllocRefDynamic.swift
   SimplifyApply.swift
   SimplifyBeginBorrow.swift
   SimplifyBeginCOWMutation.swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyAllocRefDynamic.swift b/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyAllocRefDynamic.swift
@@ -0,0 +1,54 @@
+//===--- SimplifyAllocRefDynamic.swift ------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension AllocRefDynamicInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    /// Optimize alloc_ref_dynamic of a known type to alloc_ref:
+    ///
+    ///   %3 = metatype SubClass.Type
+    ///   %4 = upcast %3 : SubClass.Type to BaseClass.Type
+    ///   %6 = alloc_ref_dynamic [...] %4 : BaseClass.Type, $BaseClass
+    ///   %8 = (... some use of ...) %6 : $BaseClass
+    /// ->
+    ///   %6 = alloc_ref [...] $SubClass
+    ///   %7 = upcast %6 : $SubClass to $BaseClass
+    ///   %8 = (... some use of ...) %7 : $BaseClass
+
+    let type: Type
+    let emitUpcast: Bool
+    if let metatypeInst = metatypeOperand.value as? MetatypeInst {
+      type = metatypeInst.type.loweredInstanceTypeOfMetatype(in: parentFunction)
+      emitUpcast = false
+    } else if let upcastInst = metatypeOperand.value as? UpcastInst,
+        let metatypeInst = upcastInst.operands[0].value as? MetatypeInst {
+      type = metatypeInst.type.loweredInstanceTypeOfMetatype(in: parentFunction)
+      emitUpcast = true
+    } else {
+      return
+    }
+
+    let builder = Builder(before: self, context)
+    let newAlloc = builder.createAllocRef(type, isObjC: self.isObjC, canAllocOnStack: self.canAllocOnStack, isBare: false,
+      tailAllocatedTypes: self.tailAllocatedTypes, tailAllocatedCounts: Array(self.tailAllocatedCounts.values))
+    
+    let result: Value
+    if emitUpcast {
+      result = builder.createUpcast(from: newAlloc, to: self.type)
+    } else {
+      result = newAlloc
+    }
+    uses.replaceAll(with: result, context)
+    context.erase(instruction: self)
+  }
+}
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/SwiftCompilerSources/Sources/SIL/Builder.swift
@@ -89,6 +89,14 @@ public struct Builder {
     let literal = bridged.createIntegerLiteral(type.bridged, value)
     return notifyNew(literal.getAs(IntegerLiteralInst.self))
   }
+    
+  public func createAllocRef(_ type: Type, isObjC: Bool = false, canAllocOnStack: Bool = false, isBare: Bool = false,
+                             tailAllocatedTypes: TypeArray, tailAllocatedCounts: [Value]) -> AllocRefInst {
+    return tailAllocatedCounts.withBridgedValues { countsRef in
+      let dr = bridged.createAllocRef(type.bridged, isObjC, canAllocOnStack, isBare, tailAllocatedTypes.bridged, countsRef)
+      return notifyNew(dr.getAs(AllocRefInst.self))
+    }
+  }
 
   public func createAllocStack(_ type: Type, hasDynamicLifetime: Bool = false,
                                isLexical: Bool = false, isFromVarDecl: Bool = false,
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -1196,6 +1196,11 @@ final public class AllocRefDynamicInst : AllocRefInstBase {
   public var isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType: Bool {
     bridged.AllocRefDynamicInst_isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType()
   }
+
+  public var metatypeOperand: Operand {
+    let numTailTypes = bridged.AllocRefInstBase_getNumTailTypes()
+    return operands[numTailTypes]
+  }
 }
 
 final public class AllocBoxInst : SingleValueInstruction, Allocation, DebugVariableInstruction {
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift
@@ -207,7 +207,7 @@ extension Type: Equatable {
 }
 
 public struct TypeArray : RandomAccessCollection, CustomReflectable {
-  private let bridged: BridgedSILTypeArray
+  public let bridged: BridgedSILTypeArray
 
   public var startIndex: Int { return 0 }
   public var endIndex: Int { return bridged.getCount() }
diff --git a/docs/EmbeddedSwift/EmbeddedSwiftStatus.md b/docs/EmbeddedSwift/EmbeddedSwiftStatus.md
@@ -43,6 +43,7 @@ This status table describes which of the following standard library features can
 | Integer parsing                                            | No     |
 | KeyPaths                                                   | Partial (only compile-time constant key paths to stored properties supported, only usable in MemoryLayout and UnsafePointer APIs)     |
 | Lazy collections                                           | No     |
+| ManagedBuffer                                              | Yes    |
 | Mirror (runtime reflection)                                | No, intentionally unsupported long-term |
 | Objective-C bridging                                       | No, intentionally unsupported long-term |
 | Optional                                                   | Yes    |
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -1306,6 +1306,11 @@ struct BridgedBuilder{
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createCondFail(BridgedValue condition,
                                                                        BridgedStringRef message) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createIntegerLiteral(BridgedType type, SwiftInt value) const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createAllocRef(BridgedType type,
+    bool objc, bool canAllocOnStack, bool isBare,
+    BridgedSILTypeArray elementTypes, BridgedValueArray elementCountOperands) const;
+
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction
   createAllocStack(BridgedType type, bool hasDynamicLifetime, bool isLexical,
                    bool isFromVarDecl, bool wasMoved) const;
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -1628,6 +1628,17 @@ BridgedInstruction BridgedBuilder::createIntegerLiteral(BridgedType type, SwiftI
       unbridged().createIntegerLiteral(regularLoc(), type.unbridged(), value)};
 }
 
+BridgedInstruction BridgedBuilder::createAllocRef(BridgedType type,
+    bool objc, bool canAllocOnStack, bool isBare,
+    BridgedSILTypeArray elementTypes, BridgedValueArray elementCountOperands) const {
+  llvm::SmallVector<swift::SILValue, 16> elementCountOperandsValues;
+  return {unbridged().createAllocRef(
+      regularLoc(), type.unbridged(), objc, canAllocOnStack, isBare,
+      elementTypes.unbridged(),
+      elementCountOperands.getValues(elementCountOperandsValues)
+      )};
+}
+
 BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,
                                                     bool hasDynamicLifetime,
                                                     bool isLexical,
diff --git a/stdlib/public/core/EmbeddedRuntime.swift b/stdlib/public/core/EmbeddedRuntime.swift
@@ -206,6 +206,15 @@ public func swift_dynamicCastClass(object: UnsafeMutableRawPointer, targetMetada
   return object
 }
 
+@_cdecl("swift_dynamicCastClassUnconditional")
+public func swift_dynamicCastClassUnconditional(object: UnsafeMutableRawPointer, targetMetadata: UnsafeRawPointer,
+    file: UnsafePointer<CChar>, line: CUnsignedInt, column: CUnsignedInt) -> UnsafeMutableRawPointer {
+  guard let result = swift_dynamicCastClass(object: object, targetMetadata: targetMetadata) else {
+    Builtin.int_trap()
+  }
+  return result
+}
+
 @_cdecl("swift_isUniquelyReferenced_native")
 public func swift_isUniquelyReferenced_native(object: Builtin.RawPointer) -> Bool {
   if !isValidPointerForNativeRetain(object: object) { return false }
diff --git a/stdlib/public/core/ManagedBuffer.swift b/stdlib/public/core/ManagedBuffer.swift
@@ -77,6 +77,11 @@ extension ManagedBuffer where Element: ~Copyable {
   /// an initial `Header`.
   @_preInverseGenerics
   @inlinable
+  #if $Embedded
+  // Transparent in Embedded Swift to avoid needing "self" as a metatype. By
+  // inlining into the caller, we'll know the concrete type instead.
+  @_transparent
+  #endif
   public final class func create(
     minimumCapacity: Int,
     makingHeaderWith factory: (ManagedBuffer<Header, Element>) throws -> Header
@@ -290,7 +295,9 @@ public struct ManagedBufferPointer<
   @_preInverseGenerics
   @inlinable
   public init(unsafeBufferObject buffer: AnyObject) {
+    #if !$Embedded
     ManagedBufferPointer._checkValidBufferClass(type(of: buffer))
+    #endif
 
     self._nativeBuffer = Builtin.unsafeCastToNativeObject(buffer)
   }
@@ -308,7 +315,10 @@ public struct ManagedBufferPointer<
   @_preInverseGenerics
   @inlinable
   internal init(_uncheckedUnsafeBufferObject buffer: AnyObject) {
+    #if !$Embedded
     ManagedBufferPointer._internalInvariantValidBufferClass(type(of: buffer))
+    #endif
+
     self._nativeBuffer = Builtin.unsafeCastToNativeObject(buffer)
   }
 
diff --git a/test/SILOptimizer/simplify_alloc_ref_dynamic.sil b/test/SILOptimizer/simplify_alloc_ref_dynamic.sil
@@ -0,0 +1,52 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -onone-simplification -simplify-instruction=alloc_ref_dynamic | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+import Swift
+import Builtin
+
+class BaseClass {
+  init()
+}
+
+class SubClass: BaseClass {
+  override init()
+}
+
+// CHECK-LABEL: sil [ossa] @test_alloc_ref_dynamic_with_upcast
+// CHECK:       bb0(%0 : $Int):
+// CHECK:         struct_extract %0 : $Int, #Int._value
+// CHECK:         builtin "truncOrBitCast_Int64_Word"({{.*}} : $Builtin.Int64) : $Builtin.Word
+// CHECK:         [[AL:%.*]] = alloc_ref [tail_elems $Int * {{.*}} : $Builtin.Word] $SubClass
+// CHECK:         [[UP:%.*]] = upcast [[AL]] : $SubClass to $BaseClass
+// CHECK:         [[MO:%.*]] = move_value [lexical] [var_decl] [[UP]] : $BaseClass
+// CHECK:         return [[MO]] : $BaseClass
+// CHECK:       } // end sil function 'test_alloc_ref_dynamic_with_upcast'
+sil [ossa] @test_alloc_ref_dynamic_with_upcast : $@convention(thin) (Int) -> @owned BaseClass {
+bb0(%0 : $Int):
+  %4 = metatype $@thick SubClass.Type
+  %5 = upcast %4 : $@thick SubClass.Type to $@thick BaseClass.Type
+  %10 = struct_extract %0 : $Int, #Int._value
+  %11 = builtin "truncOrBitCast_Int64_Word"(%10 : $Builtin.Int64) : $Builtin.Word
+  %12 = alloc_ref_dynamic [tail_elems $Int * %11 : $Builtin.Word] %5 : $@thick BaseClass.Type, $BaseClass
+  %13 = move_value [lexical] [var_decl] %12 : $BaseClass
+  return %13 : $BaseClass
+}
+
+// CHECK-LABEL: sil [ossa] @test_alloc_ref_dynamic_without_upcast
+// CHECK:       bb0(%0 : $Int):
+// CHECK:         struct_extract %0 : $Int, #Int._value
+// CHECK:         builtin "truncOrBitCast_Int64_Word"({{.*}} : $Builtin.Int64) : $Builtin.Word
+// CHECK:         [[AL:%.*]] = alloc_ref [tail_elems $Int * {{.*}} : $Builtin.Word] $BaseClass
+// CHECK:         [[MO:%.*]] = move_value [lexical] [var_decl] [[AL]] : $BaseClass
+// CHECK:         return [[MO]] : $BaseClass
+// CHECK:       } // end sil function 'test_alloc_ref_dynamic_without_upcast'
+sil [ossa] @test_alloc_ref_dynamic_without_upcast : $@convention(thin) (Int) -> @owned BaseClass {
+bb0(%0 : $Int):
+  %4 = metatype $@thick BaseClass.Type
+  %10 = struct_extract %0 : $Int, #Int._value
+  %11 = builtin "truncOrBitCast_Int64_Word"(%10 : $Builtin.Int64) : $Builtin.Word
+  %12 = alloc_ref_dynamic [tail_elems $Int * %11 : $Builtin.Word] %4 : $@thick BaseClass.Type, $BaseClass
+  %13 = move_value [lexical] [var_decl] %12 : $BaseClass
+  return %13 : $BaseClass
+}
diff --git a/test/embedded/managed-buffer2.swift b/test/embedded/managed-buffer2.swift
@@ -0,0 +1,72 @@
+// RUN: %target-run-simple-swift(-enable-experimental-feature Embedded -parse-as-library -wmo) | %FileCheck %s
+// RUN: %target-run-simple-swift(-enable-experimental-feature Embedded -parse-as-library -wmo -O) | %FileCheck %s
+// RUN: %target-run-simple-swift(-enable-experimental-feature Embedded -parse-as-library -wmo -Osize) | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: executable_test
+// REQUIRES: optimized_stdlib
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+struct CountAndCapacity {
+  var count: Int
+  let capacity: Int
+}
+
+final class TestManagedBuffer<T> : ManagedBuffer<CountAndCapacity, T> {
+  class func create(_ capacity: Int) -> TestManagedBuffer {
+    let r = super.create(minimumCapacity: capacity) {
+      CountAndCapacity(count: 0, capacity: $0.capacity)
+    }
+    return r as! TestManagedBuffer
+  
+  }
+
+  var count: Int {
+    get { return header.count }
+    set { header.count = newValue }
+  }
+  
+  var myCapacity: Int {
+    return header.capacity
+  }
+  
+  deinit {
+    teardown()
+  }
+
+  func teardown() {
+    let count = self.count
+    
+    withUnsafeMutablePointerToElements { (x: UnsafeMutablePointer<T>) -> () in
+      for i in stride(from: 0, to: count, by: 2) {
+        (x + i).deinitialize(count: 1)
+      }
+    }
+  }
+  
+  func append(_ x: T) {
+    let count = self.count
+    precondition(count + 1 <= myCapacity)
+    
+    withUnsafeMutablePointerToElements { (p: UnsafeMutablePointer<T>) -> () in
+      (p + count).initialize(to: x)
+    }
+    self.count = count + 1
+  }
+}
+
+@main
+struct Main {
+  static func main() {
+    let s = TestManagedBuffer<Int>.create(10)
+    s.append(42)
+    s.append(777)
+    s.withUnsafeMutablePointerToElements {
+      for i in 0 ..< s.count {
+        print($0[i])
+      }
+    }
+    // CHECK: 42
+    // CHECK: 777
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -1196,6 +1196,11 @@ final public class AllocRefDynamicInst : AllocRefInstBase {`
`1196`	`1196`	`public var isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType: Bool {`
`1197`	`1197`	`bridged.AllocRefDynamicInst_isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType()`
`1198`	`1198`	`}`
	`1199`	`+`
	`1200`	`+ public var metatypeOperand: Operand {`
	`1201`	`+ let numTailTypes = bridged.AllocRefInstBase_getNumTailTypes()`
	`1202`	`+ return operands[numTailTypes]`
	`1203`	`+ }`
`1199`	`1204`	`}`
`1200`	`1205`
`1201`	`1206`	`final public class AllocBoxInst : SingleValueInstruction, Allocation, DebugVariableInstruction {`
Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ extension Type: Equatable {`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`public struct TypeArray : RandomAccessCollection, CustomReflectable {`
`210`		`- private let bridged: BridgedSILTypeArray`
	`210`	`+ public let bridged: BridgedSILTypeArray`
`211`	`211`
`212`	`212`	`public var startIndex: Int { return 0 }`
`213`	`213`	`public var endIndex: Int { return bridged.getCount() }`