SwiftCompilerSources: add ForwardingInstruction

Author: atrick

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -15,6 +15,7 @@ add_swift_compiler_module(SIL
     BasicBlock.swift
     Builder.swift
     Effects.swift
+    ForwardingInstruction.swift
     Function.swift
     GlobalVariable.swift
     Instruction.swift

SwiftCompilerSources/Sources/SIL/ForwardingInstruction.swift

@@ -0,0 +1,155 @@
+//===--- ForwardingInstruction.swift - forwarding instruction protocols ---===//
+//
+// 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 SILBridging
+
+/// An instruction that forwards ownership from operands to results.
+public protocol ForwardingInstruction : Instruction {}
+
+extension ForwardingInstruction {
+  public var singleForwardedOperand: Operand? {
+    switch self {
+    case is StructInst, is TupleInst, is LinearFunctionInst,
+      is DifferentiableFunctionInst:
+      return nil
+    case let mdi as MarkDependenceInst:
+      return mdi.valueOperand
+    case let rtboi as RefToBridgeObjectInst:
+      return rtboi.convertedOperand
+    case let tpei as TuplePackExtractInst:
+      return tpei.tupleOperand
+    case let sei as SelectEnumInst:
+      return sei.enumOperand
+    default:
+      let realOperands = self.realOperands
+      if realOperands.isEmpty {
+        // This can happen with enum instructions that have no payload.
+        return nil
+      }
+      assert(realOperands.count == 1);
+      return realOperands[0];
+    }
+  }
+
+  public var forwardedOperands: OperandArray {
+    // Some instructions have multiple real operands but only forward one.
+    if let singleForwardingOp = singleForwardedOperand {
+      return OperandArray(base: singleForwardingOp, count: 1)
+    }
+    // All others forward all operands (for enum, this may be zero operands).
+    return operands
+  }
+
+  /// If forwarding ownership is owned, then the instruction moves an owned operand to its result, ending its lifetime. If forwarding ownership is guaranteed, then the instruction propagates the lifetime of its borrows operand through its result.
+  ///
+  /// The resulting forwarded value's ownership (Value.ownership) is not identical to the instruction's forwarding ownership property. It differs when the result is trivial type. e.g. an owned or guaranteed value can be cast to a trivial type using owned or guaranteed forwarding.
+  public var forwardingOwnership: Ownership {
+    Ownership(bridged: bridged.ForwardingInst_forwardingOwnership())
+  }
+  
+  /// A forwarding instruction preserves reference counts if it has a dynamically non-trivial result in which all references are forwarded from the operand.
+  ///
+  /// A cast can only forward guaranteed values if it preserves reference counts. Such casts cannot release any references within their operand's value and cannot retain any references owned by their result.
+  public var preservesReferenceCounts: Bool {
+    bridged.ForwardingInst_preservesReferenceCounts()
+  }
+
+  /// Return true if the forwarded value has the same representation. If true, then the result can be mapped to the same storage without a move or copy.
+  public var preservesRepresentation: Bool {
+    bridged.ForwardingInst_preservesRepresentation()
+  }
+
+  /// Return true if the forwarded value is address-only either before or after forwarding.
+  public var isAddressOnly: Bool { bridged.ForwardingInst_isAddressOnly() }
+}
+
+extension Value {
+  public var forwardingInstruction: ForwardingInstruction? {
+    if let inst = definingInstruction {
+      return inst as? ForwardingInstruction
+    }
+    if let termResult = TerminatorResult(self) {
+      return termResult.terminator as? ForwardingInstruction
+    }
+    return nil
+  }
+}
+
+// An instruction that forwards a single value to a single result.
+//
+// For legacy reasons, some ForwardingInstructions that fit the SingleValueInstruction and UnaryInstruction requirements are not considered ConversionInstructions because certain routines do not want to see through them (InitExistentialValueInst, InitExistentialValueInst, OpenExistentialValueInst, OpenExistentialValueInst). This most likely has to do with type-dependent operands, although any ConversionInstruction should support type-dependent operands.
+public protocol ConversionInstruction : SingleValueInstruction,
+                                        UnaryInstruction,
+                                        ForwardingInstruction
+{}
+
+extension ConversionInstruction {
+  public var singleForwardedOperand: Operand { operand }
+}
+
+// Visit all forwarded results. Return true if all visitors return true.
+extension ForwardingInstruction {      
+  public var forwardedResults: ForwardedResults {
+    ForwardedResults(inst: self)
+  }
+}
+
+public struct ForwardedResults : Collection {
+  private let inst: Instruction
+  private let maxResults: Int
+
+  fileprivate init(inst: ForwardingInstruction) {
+    self.inst = inst
+    if let ti = inst as? TermInst {
+      self.maxResults = ti.successors.count
+    } else {
+      self.maxResults = inst.results.count
+    }
+  }
+
+  public var startIndex: Int { skipEmptyResults(at: 0) }
+
+  public var endIndex: Int { maxResults }
+
+  public func index(after index: Int) -> Int {
+    return skipEmptyResults(at: index + 1)
+  }
+
+  public subscript(_ index: Int) -> Value {
+    if let ti = inst as? TermInst {
+      return getTerminatorResult(termInst: ti, index: index)!
+    }
+    return inst.results[index]
+  }
+
+  private func skipEmptyResults(at index: Int) -> Int {
+    guard let ti = inst as? TermInst else { return index }
+    var next = index
+    while next != endIndex {
+      if getTerminatorResult(termInst: ti, index: next) != nil { break }
+      next += 1
+    }
+    return next
+  }
+
+  // Forwarding terminators have a zero or one result per successor.
+  private func getTerminatorResult(termInst: TermInst,
+    index: Int) -> Argument? {
+    let succ = termInst.successors[index]
+    guard succ.arguments.count == 1 else {
+      // The default enum payload may be empty.
+      assert(succ.arguments.count == 0, "terminator must forward a single value")
+      return nil
+    }
+    return succ.arguments[0]
+  }
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -47,6 +47,11 @@ public class Instruction : CustomStringConvertible, Hashable {
     return OperandArray(base: operands.base, count: operands.count)
   }
 
+  final public var realOperands: OperandArray {
+    let operands = bridged.getRealOperands()
+    return OperandArray(base: operands.base, count: operands.count)
+  }
+
   fileprivate var resultCount: Int { 0 }
   fileprivate func getResult(index: Int) -> Value { fatalError() }
 
@@ -296,7 +301,7 @@ final public class EndAccessInst : Instruction, UnaryInstruction {
 
 final public class EndBorrowInst : Instruction, UnaryInstruction {}
 
-final public class MarkUninitializedInst : SingleValueInstruction, UnaryInstruction {
+final public class MarkUninitializedInst : SingleValueInstruction, ConversionInstruction {
 
   /// This enum captures what the mark_uninitialized instruction is designating.
   ///
@@ -485,12 +490,12 @@ final public class BuiltinInst : SingleValueInstruction {
   }
 }
 
-final public class UpcastInst : SingleValueInstruction, UnaryInstruction {
+final public class UpcastInst : SingleValueInstruction, ConversionInstruction {
   public var fromInstance: Value { operand.value }
 }
 
 final public
-class UncheckedRefCastInst : SingleValueInstruction, UnaryInstruction {
+class UncheckedRefCastInst : SingleValueInstruction, ConversionInstruction {
   public var fromInstance: Value { operand.value }
 }
 
@@ -543,10 +548,10 @@ class OpenExistentialRefInst : SingleValueInstruction, UnaryInstruction {
 }
 
 final public
-class InitExistentialValueInst : SingleValueInstruction, UnaryInstruction {}
+class InitExistentialValueInst : SingleValueInstruction, UnaryInstruction, ForwardingInstruction {}
 
 final public
-class OpenExistentialValueInst : SingleValueInstruction, UnaryInstruction {}
+class OpenExistentialValueInst : SingleValueInstruction, UnaryInstruction, ForwardingInstruction {}
 
 final public
 class InitExistentialAddrInst : SingleValueInstruction, UnaryInstruction {}
@@ -641,10 +646,10 @@ final public class StringLiteralInst : SingleValueInstruction {
   }
 }
 
-final public class TupleInst : SingleValueInstruction {
+final public class TupleInst : SingleValueInstruction, ForwardingInstruction {
 }
 
-final public class TupleExtractInst : SingleValueInstruction, UnaryInstruction {
+final public class TupleExtractInst : SingleValueInstruction, UnaryInstruction, ForwardingInstruction  {
   public var `tuple`: Value { operand.value }
   public var fieldIndex: Int { bridged.TupleExtractInst_fieldIndex() }
 }
@@ -655,10 +660,10 @@ class TupleElementAddrInst : SingleValueInstruction, UnaryInstruction {
   public var fieldIndex: Int { bridged.TupleElementAddrInst_fieldIndex() }
 }
 
-final public class StructInst : SingleValueInstruction {
+final public class StructInst : SingleValueInstruction, ForwardingInstruction {
 }
 
-final public class StructExtractInst : SingleValueInstruction, UnaryInstruction {
+final public class StructExtractInst : SingleValueInstruction, UnaryInstruction, ForwardingInstruction {
   public var `struct`: Value { operand.value }
   public var fieldIndex: Int { bridged.StructExtractInst_fieldIndex() }
 }
@@ -673,14 +678,14 @@ public protocol EnumInstruction : AnyObject {
   var caseIndex: Int { get }
 }
 
-final public class EnumInst : SingleValueInstruction, EnumInstruction {
+final public class EnumInst : SingleValueInstruction, EnumInstruction, ForwardingInstruction {
   public var caseIndex: Int { bridged.EnumInst_caseIndex() }
 
   public var operand: Operand? { operands.first }
   public var payload: Value? { operand?.value }
 }
 
-final public class UncheckedEnumDataInst : SingleValueInstruction, UnaryInstruction, EnumInstruction {
+final public class UncheckedEnumDataInst : SingleValueInstruction, UnaryInstruction, EnumInstruction, ForwardingInstruction {
   public var `enum`: Value { operand.value }
   public var caseIndex: Int { bridged.UncheckedEnumDataInst_caseIndex() }
 }
@@ -695,6 +700,10 @@ final public class UncheckedTakeEnumDataAddrInst : SingleValueInstruction, Unary
   public var caseIndex: Int { bridged.UncheckedTakeEnumDataAddrInst_caseIndex() }
 }
 
+final public class SelectEnumInst : SingleValueInstruction {
+  public var enumOperand: Operand { operands[0] }
+}
+
 final public class RefElementAddrInst : SingleValueInstruction, UnaryInstruction {
   public var instance: Value { operand.value }
   public var fieldIndex: Int { bridged.RefElementAddrInst_fieldIndex() }
@@ -727,24 +736,24 @@ final public class KeyPathInst : SingleValueInstruction {
 }
 
 final public
-class UnconditionalCheckedCastInst : SingleValueInstruction, UnaryInstruction {
+class UnconditionalCheckedCastInst : SingleValueInstruction, ConversionInstruction {
   public override var mayTrap: Bool { true }
 }
 
 final public
-class ConvertFunctionInst : SingleValueInstruction, UnaryInstruction {
+class ConvertFunctionInst : SingleValueInstruction, ConversionInstruction {
   public var fromFunction: Value { operand.value }
 }
 
 final public
-class ThinToThickFunctionInst : SingleValueInstruction, UnaryInstruction {}
+class ThinToThickFunctionInst : SingleValueInstruction, ConversionInstruction {}
 
 final public
 class ObjCExistentialMetatypeToObjectInst : SingleValueInstruction,
-                                            UnaryInstruction {}
+                                            ConversionInstruction {}
 
 final public
-class ObjCMetatypeToObjectInst : SingleValueInstruction, UnaryInstruction {}
+class ObjCMetatypeToObjectInst : SingleValueInstruction, ConversionInstruction {}
 
 final public
 class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {
@@ -759,19 +768,23 @@ class GetAsyncContinuationAddrInst : SingleValueInstruction, UnaryInstruction {}
 
 
 final public
-class MarkDependenceInst : SingleValueInstruction {
-  public var value: Value { return operands[0].value }
-  public var base: Value { return operands[1].value }
+class MarkDependenceInst : SingleValueInstruction, ForwardingInstruction {
+  public var valueOperand: Operand { operands[0] }
+  public var baseOperand: Operand { operands[1] }
+  public var value: Value { return valueOperand.value }
+  public var base: Value { return baseOperand.value }
 }
 
-final public class RefToBridgeObjectInst : SingleValueInstruction,
-                                           UnaryInstruction {}
+final public class RefToBridgeObjectInst : SingleValueInstruction, ForwardingInstruction {
+  public var convertedOperand: Operand { operands[0] }
+  public var maskOperand: Operand { operands[1] }
+}
 
 final public class BridgeObjectToRefInst : SingleValueInstruction,
-                                           UnaryInstruction {}
+                                           ConversionInstruction {}
 
 final public class BridgeObjectToWordInst : SingleValueInstruction,
-                                           UnaryInstruction {}
+                                           ConversionInstruction {}
 
 public typealias AccessKind = swift.SILAccessKind
 
@@ -907,6 +920,15 @@ final public class ObjectInst : SingleValueInstruction {
   }
 }
 
+final public class TuplePackExtractInst: SingleValueInstruction, ForwardingInstruction {
+  public var indexOperand: Operand { operands[0] }
+  public var tupleOperand: Operand { operands[1] }
+}
+
+final public class DifferentiableFunctionInst: SingleValueInstruction, ForwardingInstruction {}
+
+final public class LinearFunctionInst: SingleValueInstruction, ForwardingInstruction {}
+
 //===----------------------------------------------------------------------===//
 //                      single-value allocation instructions
 //===----------------------------------------------------------------------===//
@@ -961,11 +983,11 @@ final public class BeginCOWMutationInst : MultipleValueInstruction,
   public var instanceResult: Value { return getResult(index: 1) }
 }
 
-final public class DestructureStructInst : MultipleValueInstruction, UnaryInstruction {
+final public class DestructureStructInst : MultipleValueInstruction, UnaryInstruction, ForwardingInstruction {
   public var `struct`: Value { operand.value }
 }
 
-final public class DestructureTupleInst : MultipleValueInstruction, UnaryInstruction {
+final public class DestructureTupleInst : MultipleValueInstruction, UnaryInstruction, ForwardingInstruction {
   public var `tuple`: Value { operand.value }
 }
 
@@ -1059,7 +1081,7 @@ final public class CondBranchInst : TermInst {
 final public class SwitchValueInst : TermInst {
 }
 
-final public class SwitchEnumInst : TermInst {
+final public class SwitchEnumInst : TermInst, ForwardingInstruction {
 
   public var enumOp: Value { operands[0].value }
 
@@ -1102,7 +1124,7 @@ final public class DynamicMethodBranchInst : TermInst {
 final public class AwaitAsyncContinuationInst : TermInst, UnaryInstruction {
 }
 
-final public class CheckedCastBranchInst : TermInst, UnaryInstruction {
+final public class CheckedCastBranchInst : TermInst, UnaryInstruction, ForwardingInstruction {
   public var source: Value { operand.value }
   public var successBlock: BasicBlock { bridged.CheckedCastBranch_getSuccessBlock().block }
   public var failureBlock: BasicBlock { bridged.CheckedCastBranch_getFailureBlock().block }