Bridging: APIs for PackSpecialization pass

Author: aidan-hall

SwiftCompilerSources/Sources/AST/Type.swift

@@ -146,6 +146,8 @@ extension TypeProperties {
   public var isExistentialMetatype: Bool { rawType.bridged.isExistentialMetatypeType() }
   public var isDynamicSelf: Bool { rawType.bridged.isDynamicSelf()}
   public var isBox: Bool { rawType.bridged.isBox() }
+  public var isPack: Bool { rawType.bridged.isPack() }
+  public var isSILPack: Bool { rawType.bridged.isSILPack() }
 
   public var canBeClass: Type.TraitResult { rawType.bridged.canBeClass().result }
 
@@ -263,6 +265,14 @@ extension TypeProperties {
   public func checkConformance(to protocol: ProtocolDecl) -> Conformance {
     return Conformance(bridged: rawType.bridged.checkConformance(`protocol`.bridged))
   }
+
+  public var containsSILPackExpansionType: Bool {
+    return rawType.bridged.containsSILPackExpansionType()
+  }
+
+  public var isSILPackElementAddress: Bool {
+    return rawType.bridged.isSILPackElementAddress()
+  }
 }
 
 public struct TypeArray : RandomAccessCollection, CustomReflectable {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ConstantCapturePropagation.swift

@@ -152,8 +152,8 @@ private func specializeClosure(specializedName: String,
   newParams.append(contentsOf: nonConstantArguments.map { partialApply.parameter(for: $0)! })
 
   let isGeneric = newParams.contains { $0.type.hasTypeParameter } ||
-                  callee.convention.results.contains { $0.type.hasTypeParameter() } ||
-                  callee.convention.errorResult?.type.hasTypeParameter() ?? false
+                  callee.convention.results.contains { $0.type.hasTypeParameter } ||
+                  callee.convention.errorResult?.type.hasTypeParameter ?? false
 
   let specializedClosure = context.createSpecializedFunctionDeclaration(from: callee,
                                                                         withName: specializedName,

SwiftCompilerSources/Sources/Optimizer/PassManager/FunctionPassContext.swift

@@ -158,19 +158,43 @@ struct FunctionPassContext : MutatingContext {
     }
   }
 
-  func createSpecializedFunctionDeclaration(from original: Function, withName specializedFunctionName: String,
-                                            withParams specializedParameters: [ParameterInfo],
-                                            makeThin: Bool = false,
-                                            makeBare: Bool = false,
-                                            preserveGenericSignature: Bool = true) -> Function
-  {
+  func mangle(withExplodedPackArguments argIndices: [Int], from original: Function) -> String {
+    return argIndices.withBridgedArrayRef { bridgedArgIndices in
+      String(taking: bridgedPassContext.mangleWithExplodedPackArgs(bridgedArgIndices, original.bridged))
+    }
+  }
+
+  func createSpecializedFunctionDeclaration(
+    from original: Function, withName specializedFunctionName: String,
+    withParams specializedParameters: [ParameterInfo],
+    withResults specializedResults: [ResultInfo]? = nil,
+    makeThin: Bool = false,
+    makeBare: Bool = false,
+    preserveGenericSignature: Bool = true
+  ) -> Function {
     return specializedFunctionName._withBridgedStringRef { nameRef in
       let bridgedParamInfos = specializedParameters.map { $0._bridged }
 
       return bridgedParamInfos.withUnsafeBufferPointer { paramBuf in
-        bridgedPassContext.createSpecializedFunctionDeclaration(nameRef, paramBuf.baseAddress, paramBuf.count,
-                                                                original.bridged, makeThin, makeBare,
-                                                                preserveGenericSignature).function
+
+        if let bridgedResultInfos = specializedResults?.map({ $0._bridged }) {
+
+          return bridgedResultInfos.withUnsafeBufferPointer { resultBuf in
+            return bridgedPassContext.createSpecializedFunctionDeclaration(
+              nameRef, paramBuf.baseAddress, paramBuf.count,
+              resultBuf.baseAddress, resultBuf.count,
+              original.bridged, makeThin, makeBare,
+              preserveGenericSignature
+            ).function
+          }
+        } else {
+          return bridgedPassContext.createSpecializedFunctionDeclaration(
+            nameRef, paramBuf.baseAddress, paramBuf.count,
+            nil, 0,
+            original.bridged, makeThin, makeBare,
+            preserveGenericSignature
+          ).function
+        }
       }
     }
   }

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -248,12 +248,33 @@ public struct Builder {
     return notifyNew(allocStack.getAs(AllocStackInst.self))
   }
 
+  public func createAllocPack(_ packType: Type) -> AllocPackInst {
+    let allocPack = bridged.createAllocPack(packType.bridged)
+    return notifyNew(allocPack.getAs(AllocPackInst.self))
+  }
+
+  public func createAllocPackMetadata() -> AllocPackMetadataInst {
+    let allocPackMetadata = bridged.createAllocPackMetadata()
+    return notifyNew(allocPackMetadata.getAs(AllocPackMetadataInst.self))
+  }
+
+  public func createAllocPackMetadata(_ packType: Type) -> AllocPackMetadataInst {
+    let allocPackMetadata = bridged.createAllocPackMetadata(packType.bridged)
+    return notifyNew(allocPackMetadata.getAs(AllocPackMetadataInst.self))
+  }
+
   @discardableResult
   public func createDeallocStack(_ operand: Value) -> DeallocStackInst {
     let dr = bridged.createDeallocStack(operand.bridged)
     return notifyNew(dr.getAs(DeallocStackInst.self))
   }
 
+  @discardableResult
+  public func createDeallocPack(_ operand: Value) -> DeallocPackInst {
+    let dr = bridged.createDeallocPack(operand.bridged)
+    return notifyNew(dr.getAs(DeallocPackInst.self))
+  }
+
   @discardableResult
   public func createDeallocStackRef(_ operand: Value) -> DeallocStackRefInst {
     let dr = bridged.createDeallocStackRef(operand.bridged)
@@ -689,6 +710,11 @@ public struct Builder {
     return notifyNew(store.getAs(StoreInst.self))
   }
 
+  public func createStoreBorrow(source: Value, destination: Value) -> StoreBorrowInst {
+    let storeBorrow = bridged.createStoreBorrow(source.bridged, destination.bridged)
+    return notifyNew(storeBorrow.getAs(StoreBorrowInst.self))
+  }
+
   public func createInitExistentialRef(instance: Value,
                                        existentialType: Type,
                                        formalConcreteType: CanonicalType,
@@ -713,6 +739,22 @@ public struct Builder {
     return notifyNew(initExistential.getAs(InitExistentialMetatypeInst.self))
   }
 
+  public func createScalarPackIndex(componentIndex: Int, indexedPackType: CanonicalType) -> ScalarPackIndexInst {
+    let scalarPackIndex = bridged.createScalarPackIndex(SwiftInt(componentIndex), indexedPackType.bridged)
+    return notifyNew(scalarPackIndex.getAs(ScalarPackIndexInst.self))
+  }
+
+  public func createPackElementGet(packIndex: Value, pack: Value, elementType: Type) -> PackElementGetInst {
+    let packElementGet = bridged.createPackElementGet(packIndex.bridged, pack.bridged, elementType.bridged)
+    return notifyNew(packElementGet.getAs(PackElementGetInst.self))
+  }
+
+  @discardableResult
+  public func createPackElementSet(elementValue: Value, packIndex: Value, pack: Value) -> PackElementSetInst {
+    let packElementSet = bridged.createPackElementSet(elementValue.bridged, packIndex.bridged, pack.bridged)
+    return notifyNew(packElementSet.getAs(PackElementSetInst.self))
+  }
+
   public func createMetatype(
     ofInstanceType instanceType: CanonicalType,
     representation: AST.`Type`.MetatypeRepresentation

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -140,17 +140,31 @@ public struct ResultInfo : CustomStringConvertible {
   /// calling convention of the parameter.
   ///
   /// TODO: For most purposes, you probably want \c returnValueType.
-  public let type: BridgedASTType
+  public let type: CanonicalType
   public let convention: ResultConvention
+  public let options: UInt8
   public let hasLoweredAddresses: Bool
 
+  // Must be kept consistent with 'SILResultInfo::Flag'
+  public enum Flag : UInt8 {
+    case notDifferentiable = 0x1
+    case isSending = 0x2
+  };
+
+  public init(type: CanonicalType, convention: ResultConvention, options: UInt8, hasLoweredAddresses: Bool) {
+    self.type = type
+    self.convention = convention
+    self.options = options
+    self.hasLoweredAddresses = hasLoweredAddresses
+  }
+
   /// Is this result returned indirectly in SIL? Most formally
   /// indirect results can be returned directly in SIL. This depends
   /// on whether the calling function has lowered addresses.
   public var isSILIndirect: Bool {
     switch convention {
     case .indirect:
-      return hasLoweredAddresses || type.isExistentialArchetypeWithError()
+      return hasLoweredAddresses || type.isExistentialArchetypeWithError
     case .pack:
       return true
     case .owned, .unowned, .unownedInnerPointer, .autoreleased, .guaranteed, .guaranteedAddress, .inout:
@@ -159,8 +173,11 @@ public struct ResultInfo : CustomStringConvertible {
   }
 
   public var description: String {
-    convention.description + ": "
-    + String(taking: type.getDebugDescription())
+    convention.description + ": " + type.description
+  }
+
+  public func getReturnValueType(function: Function) -> CanonicalType {
+    CanonicalType(bridged: self._bridged.getReturnValueType(function.bridged))
   }
 }
 
@@ -234,6 +251,10 @@ public struct ParameterInfo : CustomStringConvertible {
   public func hasOption(_ flag: Flag) -> Bool {
     return options & flag.rawValue != 0
   }
+
+  public func getArgumentType(function: Function) -> CanonicalType {
+    CanonicalType(bridged: self._bridged.getArgumentType(function.bridged))
+  }
 }
 
 extension FunctionConvention {
@@ -443,17 +464,22 @@ public enum ResultConvention : CustomStringConvertible {
 
 extension ResultInfo {
   init(bridged: BridgedResultInfo, hasLoweredAddresses: Bool) {
-    self.type = BridgedASTType(type: bridged.type)
+    self.type = CanonicalType(bridged: bridged.type)
     self.convention = ResultConvention(bridged: bridged.convention)
     self.hasLoweredAddresses = hasLoweredAddresses
+    self.options = bridged.options
   }
   init?(bridged: OptionalBridgedResultInfo, hasLoweredAddresses: Bool) {
-    guard let t = bridged.type else {
+    if bridged.type.getRawType().type == nil {
       return nil
     }
-    self.type = BridgedASTType(type: t)
+    self.type = CanonicalType(bridged: bridged.type)
     self.convention = ResultConvention(bridged: bridged.convention)
     self.hasLoweredAddresses = hasLoweredAddresses
+    self.options = bridged.options
+  }
+  public var _bridged: BridgedResultInfo {
+    BridgedResultInfo(type.bridged, convention.bridged, options)
   }
 }
 
@@ -473,6 +499,20 @@ extension ResultConvention {
         fatalError("unsupported result convention")
     }
   }
+
+  var bridged: BridgedResultConvention {
+    switch self {
+    case .indirect:            return .Indirect
+    case .owned:               return .Owned
+    case .unowned:             return .Unowned
+    case .unownedInnerPointer: return .UnownedInnerPointer
+    case .autoreleased:        return .Autoreleased
+    case .pack:                return .Pack
+    case .guaranteed:          return .Guaranteed
+    case .guaranteedAddress:   return .GuaranteedAddress
+    case .inout:               return .Inout
+    }
+  }
 }
 
 extension ParameterInfo {

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -96,7 +96,7 @@ public class Instruction : CustomStringConvertible, Hashable {
     BridgedContext.moveInstructionBefore(bridged, otherInstruction.bridged)
     context.notifyInstructionsChanged()
   }
-  
+
   public final func copy(before otherInstruction: Instruction, _ context: some MutatingContext) {
     BridgedContext.copyInstructionBefore(bridged, otherInstruction.bridged)
     context.notifyInstructionsChanged()
@@ -182,7 +182,7 @@ public class Instruction : CustomStringConvertible, Hashable {
   public static func ==(lhs: Instruction, rhs: Instruction) -> Bool {
     lhs === rhs
   }
-  
+
   public func isIdenticalTo(_ otherInst: Instruction) -> Bool {
     return bridged.isIdenticalTo(otherInst.bridged)
   }
@@ -1094,7 +1094,7 @@ final public class RefElementAddrInst : SingleValueInstruction, UnaryInstruction
   public var fieldIsLet: Bool { bridged.RefElementAddrInst_fieldIsLet() }
 
   public var isImmutable: Bool { bridged.RefElementAddrInst_isImmutable() }
-  
+
   public func set(isImmutable: Bool, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
     bridged.RefElementAddrInst_setImmutable(isImmutable)
@@ -1141,7 +1141,7 @@ final public class KeyPathInst : SingleValueInstruction {
 final public
 class UnconditionalCheckedCastInst : SingleValueInstruction, UnaryInstruction {
   public override var mayTrap: Bool { true }
-  
+
   public var sourceFormalType: CanonicalType {
     CanonicalType(bridged: bridged.UnconditionalCheckedCast_getSourceFormalType())
   }
@@ -1814,10 +1814,29 @@ final public class DeallocPackInst : Instruction, UnaryInstruction, Deallocation
 final public class DeallocPackMetadataInst : Instruction, Deallocation {}
 
 final public class OpenPackElementInst : SingleValueInstruction {}
-final public class PackLengthInst : SingleValueInstruction {}
-final public class DynamicPackIndexInst : SingleValueInstruction {}
-final public class PackPackIndexInst : SingleValueInstruction {}
-final public class ScalarPackIndexInst : SingleValueInstruction {}
+final public class PackLengthInst : SingleValueInstruction {
+  public var packType: CanonicalType {
+    CanonicalType(bridged: bridged.PackLengthInst_getPackType())
+  }
+}
+
+public protocol AnyPackIndexInst : SingleValueInstruction {
+  var indexedPackType: CanonicalType { get }
+}
+
+extension AnyPackIndexInst {
+  public var indexedPackType: CanonicalType {
+    CanonicalType(bridged: bridged.AnyPackIndexInst_getIndexedPackType())
+  }
+}
+
+final public class DynamicPackIndexInst : SingleValueInstruction, AnyPackIndexInst {}
+final public class PackPackIndexInst : SingleValueInstruction, AnyPackIndexInst {}
+final public class ScalarPackIndexInst : SingleValueInstruction, AnyPackIndexInst {
+  public var componentIndex: Int {
+    Int(bridged.ScalarPackIndexInst_getComponentIndex())
+  }
+}
 
 final public class TuplePackExtractInst: SingleValueInstruction {
   public var indexOperand: Operand { operands[0] }
@@ -1842,7 +1861,7 @@ public class TermInst : Instruction {
     let succArray = bridged.TermInst_getSuccessors()
     return SuccessorArray(base: succArray.base, count: succArray.count)
   }
-  
+
   public var isFunctionExiting: Bool { false }
 
   public final func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {
@@ -1888,6 +1907,9 @@ final public class YieldInst : TermInst {
   public func convention(of operand: Operand) -> ArgumentConvention {
     return bridged.YieldInst_getConvention(operand.bridged).convention
   }
+
+  public var resumeBlock: BasicBlock { bridged.YieldInst_getResumeBB().block }
+  public var unwindBlock: BasicBlock { bridged.YieldInst_getUnwindBB().block }
 }
 
 final public class UnwindInst : TermInst {
@@ -1997,11 +2019,11 @@ final public class AwaitAsyncContinuationInst : TermInst, UnaryInstruction {
 
 public struct CheckedCastInstOptions {
   var storage: UInt8 = 0
-  
+
   var bridged: BridgedInstruction.CheckedCastInstOptions {
     .init(storage: storage)
   }
-  
+
   var isolatedConformances: CastingIsolatedConformances {
     return (storage & 0x01) != 0 ? .prohibit : .allow
   }