Merge pull request #70485 from atrick/bridge-util

[NFC] Bridging and utilities for SwiftCompilerSources required by lifetime dependence utilities.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -59,6 +59,19 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     self.inExclusiveRange.insert(beginInst)
   }
 
+  init(for value: Value, _ context: some Context) {
+    var begin: Instruction
+    if let def = value.definingInstruction {
+      begin = def
+    } else if let result = TerminatorResult(value) {
+      begin = result.terminator
+    } else {
+      assert(Phi(value) != nil || value is FunctionArgument)
+      begin = value.parentBlock.instructions.first!
+    }
+    self = InstructionRange(begin: begin, context)
+  }
+
   /// Insert a potential end instruction.
   mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
@@ -103,12 +116,21 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Returns the end instructions.
+  ///
+  /// Warning: this returns `begin` if no instructions were inserted.
   var ends: LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>, Instruction> {
     blockRange.ends.map {
       $0.instructions.reversed().first(where: { insertedInsts.contains($0)})!
     }
   }
 
+  // Returns the exit blocks.
+  var exitBlocks: LazySequence<FlattenSequence<
+                    LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
+                                    LazyFilterSequence<SuccessorArray>>>> {
+    blockRange.exits
+  }
+
   /// Returns the exit instructions.
   var exits: LazyMapSequence<LazySequence<FlattenSequence<
                                LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import ASTBridging
 import SIL
 import OptimizerBridging
 

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -120,6 +120,12 @@ extension ApplySite {
     return nil
   }
 
+  /// Get the conventions of the callee without the applied substitutions.
+  public var originalCalleeConvention: FunctionConvention {
+    FunctionConvention(for: callee.type.bridged.getASTType(),
+      in: parentFunction)
+  }
+
   public func hasSemanticsAttribute(_ attr: StaticString) -> Bool {
     if let callee = referencedFunction {
       return callee.hasSemanticsAttribute(attr)

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -28,6 +28,8 @@ public class Argument : Value, Hashable {
   public var index: Int {
     return parentBlock.arguments.firstIndex(of: self)!
   }
+
+  public var isReborrow: Bool { bridged.isReborrow() }
 
   public static func ==(lhs: Argument, rhs: Argument) -> Bool {
     lhs === rhs
@@ -85,30 +87,39 @@ public struct Phi {
     return value.parentBlock
   }
 
-  public var incomingOperands: LazyMapSequence<PredecessorList, Operand> {
+  public func incomingOperand(inPredecessor predecessor: BasicBlock)
+  -> Operand {
     let blockArgIdx = value.index
-    return predecessors.lazy.map {
-      switch $0.terminator {
-        case let br as BranchInst:
-          return br.operands[blockArgIdx]
-        case let condBr as CondBranchInst:
-          if condBr.trueBlock == successor {
-            assert(condBr.falseBlock != successor)
-            return condBr.trueOperands[blockArgIdx]
-          } else {
-            assert(condBr.falseBlock == successor)
-            return condBr.falseOperands[blockArgIdx]
-          }
-        default:
-          fatalError("wrong terminator for phi-argument")
+    switch predecessor.terminator {
+    case let br as BranchInst:
+      return br.operands[blockArgIdx]
+    case let condBr as CondBranchInst:
+      if condBr.trueBlock == successor {
+        assert(condBr.falseBlock != successor)
+        return condBr.trueOperands[blockArgIdx]
+      } else {
+        assert(condBr.falseBlock == successor)
+        return condBr.falseOperands[blockArgIdx]
       }
+    default:
+      fatalError("wrong terminator for phi-argument")
     }
   }
 
+  public var incomingOperands: LazyMapSequence<PredecessorList, Operand> {
+    predecessors.lazy.map { incomingOperand(inPredecessor: $0) }
+  }
+
   public var incomingValues: LazyMapSequence<LazyMapSequence<PredecessorList, Operand>, Value> {
     incomingOperands.lazy.map { $0.value }
   }
 
+  public var isReborrow: Bool { value.isReborrow }
+
+  public var endsLifetime: Bool {
+    value.ownership == .owned || value.isReborrow
+  }
+
   public static func ==(lhs: Phi, rhs: Phi) -> Bool {
     lhs.value === rhs.value
   }

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -53,6 +53,10 @@ final public class BasicBlock : CustomStringConvertible, HasShortDescription, Eq
 
   public var hasSinglePredecessor: Bool { singlePredecessor != nil }
 
+  public var singleSuccessor: BasicBlock? {
+    successors.count == 1 ? successors[0] : nil
+  }
+
   /// The index of the basic block in its function.
   /// This has O(n) complexity. Only use it for debugging
   public var index: Int {

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -17,6 +17,7 @@ add_swift_compiler_module(SIL
     Effects.swift
     ForwardingInstruction.swift
     Function.swift
+    FunctionConvention.swift
     GlobalVariable.swift
     Instruction.swift
     Location.swift

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -33,6 +33,8 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
 
   public var hasOwnership: Bool { bridged.hasOwnership() }
 
+  public var hasLoweredAddresses: Bool { bridged.hasLoweredAddresses() }
+
   /// Returns true if the function is a definition and not only an external declaration.
   ///
   /// This is the case if the functioun contains a body, i.e. some basic blocks.

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -0,0 +1,163 @@
+//===--- FunctionConvention.swift - function conventions ------------------===//
+//
+// 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
+
+/// SIL function convention based on the AST function type and SIL stage.
+public struct FunctionConvention {
+  let bridgedFunctionType: BridgedASTType
+  let hasLoweredAddresses: Bool
+
+  init(for bridgedFunctionType: BridgedASTType, in function: Function) {
+    self.bridgedFunctionType = bridgedFunctionType
+    self.hasLoweredAddresses = function.hasLoweredAddresses
+  }
+
+  struct Results : Collection {
+    let bridged: BridgedResultInfoArray
+    let hasLoweredAddresses: Bool
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { bridged.count() }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> ResultInfo {
+      return ResultInfo(bridged: bridged.at(index),
+        hasLoweredAddresses: hasLoweredAddresses)
+    }
+  }
+
+  var results: Results {
+    Results(bridged: bridgedFunctionType.SILFunctionType_getResults(),
+      hasLoweredAddresses: hasLoweredAddresses)
+  }
+
+  /// Number of SIL arguments for indirect results, not including error results.
+  var indirectSILResultCount: UInt {
+    // TODO: Return packs directly in lowered-address mode
+    return hasLoweredAddresses
+    ? bridgedFunctionType.SILFunctionType_getNumIndirectFormalResults()
+    : bridgedFunctionType.SILFunctionType_getNumPackResults()
+  }
+
+  var errorResult: ResultInfo? {
+    guard bridgedFunctionType.SILFunctionType_hasErrorResult() else {
+      return nil
+    }
+    return results[0]
+  }
+
+  /// The number of SIL error results passed as address-typed arguments.
+  var indirectSILErrorResultCount: UInt {
+    guard hasLoweredAddresses else { return 0 }
+    return errorResult?.convention == .indirect ? 1 : 0
+  }
+
+  var parameterCount: UInt {
+    bridgedFunctionType.SILFunctionType_getNumParameters()
+  }
+
+  /// The SIL argument index of the function type's first parameter.
+  var firstParameterIndex: UInt {
+    indirectSILResultCount + indirectSILErrorResultCount
+  }
+
+  // The SIL argument index of the 'self' paramter.
+  var selfIndex: UInt? {
+    guard bridgedFunctionType.SILFunctionType_hasSelfParam() else { return nil }
+    return firstParameterIndex + parameterCount - 1
+  }
+}
+
+/// A function result type and the rules for returning it in SIL.
+struct ResultInfo {
+  /// The unsubstituted parameter type that describes the abstract calling convention of the parameter.
+  ///
+  /// TODO: For most purposes, you probably want \c returnValueType.
+  let interfaceType: BridgedASTType
+  let convention: ResultConvention
+  let hasLoweredAddresses: Bool
+
+  /// Is this result returned indirectly in SIL? Most formally indirect results can be returned directly in SIL. This depends on the calling function.
+  var isSILIndirect: Bool {
+    switch convention {
+    case .indirect:
+      return hasLoweredAddresses || interfaceType.isOpenedExistentialWithError()
+    case .pack:
+      return true
+    case .owned, .unowned, .unownedInnerPointer, .autoreleased:
+      return false
+    }
+  }
+}
+
+public enum ResultConvention {
+  /// This result is returned indirectly, i.e. by passing the address of an uninitialized object in memory.  The callee is responsible for leaving an initialized object at this address.  The callee may assume that the address does not alias any valid object.
+  case indirect
+
+  /// The caller is responsible for destroying this return value.  Its type is non-trivial.
+  case owned
+
+  /// The caller is not responsible for destroying this return value.  Its type may be trivial, or it may simply be offered unsafely.  It is valid at the instant of the return, but further operations may invalidate it.
+  case unowned
+
+  /// The caller is not responsible for destroying this return value.  The validity of the return value is dependent on the 'self' parameter, so it may be invalidated if that parameter is released.
+  case unownedInnerPointer
+
+  /// This value has been (or may have been) returned autoreleased.  The caller should make an effort to reclaim the autorelease.  The type must be a class or class existential type, and this must be the only return value.
+  case autoreleased
+
+  /// This value is a pack that is returned indirectly by passing a pack address (which may or may not be further indirected, depending on the pact type).  The callee is responsible for leaving an initialized object in each element of the pack.
+  case pack
+
+  /// Does this result convention require indirect storage? This reflects a FunctionType's conventions, as opposed to the SIL conventions that dictate SILValue types.
+  public var isASTIndirect: Bool {
+    switch self {
+    case .indirect, .pack:
+      return true
+    default:
+      return false
+    }
+  }
+  public var isASTDirect: Bool {
+    return !isASTIndirect
+  }
+}
+
+// Bridging utilities
+
+extension ResultInfo {
+  init(bridged: BridgedResultInfo, hasLoweredAddresses: Bool) {
+    self.interfaceType = BridgedASTType(type: bridged.type)
+    self.convention = ResultConvention(bridged: bridged.convention)
+    self.hasLoweredAddresses = hasLoweredAddresses
+  }
+}
+
+extension ResultConvention {
+  init(bridged: BridgedResultConvention) {
+    switch bridged {
+      case .Indirect:            self = .indirect
+      case .Owned:               self = .owned
+      case .Unowned:             self = .unowned
+      case .UnownedInnerPointer: self = .unownedInnerPointer
+      case .Autoreleased:        self = .autoreleased
+      case .Pack:                self = .pack
+      default:
+        fatalError("unsupported result convention")
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1071,6 +1071,8 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
 
   public var singleDirectResult: Value? { nil }
 
+  public var token: Value { getResult(index: resultCount - 1) }
+
   public var yieldedValues: Results {
     Results(inst: self, numResults: resultCount - 1)
   }

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -153,6 +153,10 @@ extension Sequence where Element == Operand {
   public func getSingleUser<I: Instruction>(notOfType: I.Type) -> Instruction? {
     ignoreUsers(ofType: I.self).singleUse?.instruction
   }
+
+  public var lifetimeEndingUses: LazyFilterSequence<Self> {
+    return self.lazy.filter { $0.endsLifetime }
+  }
 }
 
 extension OptionalBridgedOperand {