Swift SIL: add Value.definingBlock

and re-factor `Value.definingInstruction`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -207,7 +207,8 @@ private extension EscapeInfo {
     var dominatingBlock = value.block
 
     _ = isEscaping(object: value, visitUse: { op, _, _ in
-        if let defBlock = op.value.definingBlock, defBlock.dominates(dominatingBlock, domTree) {
+        let defBlock = op.value.definingBlock
+        if defBlock.dominates(dominatingBlock, domTree) {
           dominatingBlock = defBlock
         }
         return .continueWalking
@@ -230,25 +231,25 @@ private extension EscapeInfo {
         outerBlockRange.insert(user.block)
 
         let val = op.value
-        if let defBlock = val.definingBlock {
-          // Also insert the operand's definition. Otherwise we would miss allocation
-          // instructions (for which the `visitUse` closure is not called).
-          outerBlockRange.insert(defBlock)
-          
-          // We need to explicitly add predecessor blocks of phi-arguments becaues they
-          // are not necesesarily visited by `EscapeInfo.walkDown`.
-          // This is important for the special case where there is a back-edge from the
-          // inner range to the inner rage's begin-block:
-          //
-          //   bb0:                      // <- need to be in the outer range
-          //     br bb1(%some_init_val)
-          //   bb1(%arg):
-          //     %k = alloc_ref $Klass   // innerInstRange.begin
-          //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
-          //
-          if val is BlockArgument {
-            outerBlockRange.insert(contentsOf: defBlock.predecessors)
-          }
+        let defBlock = val.definingBlock
+
+        // Also insert the operand's definition. Otherwise we would miss allocation
+        // instructions (for which the `visitUse` closure is not called).
+        outerBlockRange.insert(defBlock)
+        
+        // We need to explicitly add predecessor blocks of phi-arguments becaues they
+        // are not necesesarily visited by `EscapeInfo.walkDown`.
+        // This is important for the special case where there is a back-edge from the
+        // inner range to the inner rage's begin-block:
+        //
+        //   bb0:                      // <- need to be in the outer range
+        //     br bb1(%some_init_val)
+        //   bb1(%arg):
+        //     %k = alloc_ref $Klass   // innerInstRange.begin
+        //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
+        //
+        if val is BlockArgument {
+          outerBlockRange.insert(contentsOf: defBlock.predecessors)
         }
         return .continueWalking
       })

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -18,6 +18,7 @@ import SILBridging
 /// Maps to both, SILPhiArgument and SILFunctionArgument.
 public class Argument : Value, Equatable {
   public var definingInstruction: Instruction? { nil }
+  public var definingBlock: BasicBlock { block }
 
   public var block: BasicBlock {
     return SILArgument_getParent(bridged).block

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -135,6 +135,7 @@ extension OptionalBridgedInstruction {
 
 public class SingleValueInstruction : Instruction, Value {
   final public var definingInstruction: Instruction? { self }
+  final public var definingBlock: BasicBlock { block }
 
   fileprivate final override var resultCount: Int { 1 }
   fileprivate final override func getResult(index: Int) -> Value { self }
@@ -151,6 +152,7 @@ public final class MultipleValueInstructionResult : Value {
   }
 
   public var definingInstruction: Instruction? { instruction }
+  public var definingBlock: BasicBlock { instruction.block }
 
   public var index: Int { MultiValueInstResult_getIndex(bridged) }
 

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -17,7 +17,16 @@ public protocol Value : AnyObject, CustomStringConvertible {
   var uses: UseList { get }
   var type: Type { get }
   var ownership: Ownership { get }
+  
+  /// The instruction which defines the value.
+  ///
+  /// This is nil if the value is not defined by an instruction, e.g. an `Argument`.
   var definingInstruction: Instruction? { get }
+  
+  /// The block where the value is defined.
+  ///
+  /// It's not legal to get the definingBlock of an `Undef` value.
+  var definingBlock: BasicBlock { get }
 }
 
 public enum Ownership {
@@ -80,32 +89,10 @@ extension Value {
     UseList(SILValue_firstUse(bridged))
   }
 
-  public var function: Function {
-    SILNode_getFunction(bridgedNode).function
-  }
+  public var function: Function { definingBlock.function }
 
   public var type: Type { SILValue_getType(bridged).type }
 
-  public var definingInstruction: Instruction? {
-    switch self {
-      case let inst as SingleValueInstruction:
-        return inst
-      case let mvi as MultipleValueInstructionResult:
-        return mvi.instruction
-      default:
-        return nil
-    }
-  }
-
-  public var definingBlock: BasicBlock? {
-    if let inst = definingInstruction {
-      return inst.block
-    }
-    if let arg = self as? Argument {
-      return arg.block
-    }
-    return nil
-  }
   public var ownership: Ownership { SILValue_getOwnership(bridged).ownership }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
@@ -154,10 +141,16 @@ extension BridgedValue {
 
 final class Undef : Value {
   public var definingInstruction: Instruction? { nil }
+  public var definingBlock: BasicBlock {
+    fatalError("undef has no defining block")
+  }
 }
 
 final class PlaceholderValue : Value {
   public var definingInstruction: Instruction? { nil }
+  public var definingBlock: BasicBlock {
+    fatalError("PlaceholderValue has no defining block")
+  }
 }
 
 extension OptionalBridgedValue {

include/swift/SIL/SILBridging.h

@@ -229,7 +229,6 @@ BridgedInstruction Operand_getUser(BridgedOperand);
 SwiftInt Operand_isTypeDependent(BridgedOperand);
 
 std::string SILNode_debugDescription(BridgedNode node);
-BridgedFunction SILNode_getFunction(BridgedNode node);
 OptionalBridgedOperand SILValue_firstUse(BridgedValue value);
 BridgedType SILValue_getType(BridgedValue value);
 BridgedOwnership SILValue_getOwnership(BridgedValue value);

lib/SIL/Utils/SILBridging.cpp

@@ -334,10 +334,6 @@ std::string SILNode_debugDescription(BridgedNode node) {
   return str;
 }
 
-BridgedFunction SILNode_getFunction(BridgedNode node) {
-  return {castToSILNode(node)->getFunction()};
-}
-
 static Operand *castToOperand(BridgedOperand operand) {
   return const_cast<Operand *>(static_cast<const Operand *>(operand.op));
 }