Optimizer: add a few "lookThrough" utilities

* move `Value.lookThoughOwnershipInstructions` from the ObjCBridgingOptimization pass to OptUtils
* add `lookThroughBorrow` and `lookThroughCopy`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -84,7 +84,7 @@ private func optimizeOptionalBridging(forArgumentOf block: BasicBlock,
   }
 
   // Check for the first ObjC -> swift bridging operation.
-  let swiftValue = lookThroughOwnershipInsts(swiftValueSwitch.enumOp)
+  let swiftValue = swiftValueSwitch.enumOp.lookThoughOwnershipInstructions
   guard let originalObjCValueSwitch = isOptionalBridging(of: swiftValue, isBridging: isBridgeToSwiftCall) else {
     return true
   }
@@ -126,7 +126,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
     return true
   }
 
-  let swiftValue = lookThroughOwnershipInsts(bridgeToObjcCall.arguments[0])
+  let swiftValue = bridgeToObjcCall.arguments[0].lookThoughOwnershipInstructions
 
   // Handle the first case: the ObjC -> swift bridging operation is optional and the swift -> ObjC
   // bridging is within a test for Optional.some, e.g.
@@ -245,18 +245,6 @@ private func removeBridgingCodeInPredecessors(of block: BasicBlock, _ context: F
   }
 }
 
-private func lookThroughOwnershipInsts(_ value: Value) -> Value {
-  // Looks like it's sufficient to support begin_borrow and copy_value for now.
-  // TODO: add move_value if needed.
-  if let bbi = value as? BeginBorrowInst {
-    return bbi.borrowedValue
-  }
-  if let cvi = value as? CopyValueInst {
-    return cvi.fromValue
-  }
-  return value
-}
-
 /// Checks for an optional bridging `switch_enum` diamond.
 ///
 /// ```

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -18,6 +18,33 @@ extension Value {
     uses.lazy.filter { !($0.instruction is DebugValueInst) }
   }
 
+  var lookThroughBorrow: Value {
+    if let beginBorrow = self as? BeginBorrowInst {
+      return beginBorrow.borrowedValue.lookThroughBorrow
+    }
+    return self
+  }
+
+  var lookThroughCopy: Value {
+    if let copy = self as? CopyValueInst {
+      return copy.fromValue.lookThroughCopy
+    }
+    return self
+  }
+
+  var lookThoughOwnershipInstructions: Value {
+    switch self {
+    case let beginBorrow as BeginBorrowInst:
+      return beginBorrow.borrowedValue.lookThoughOwnershipInstructions
+    case let copy as CopyValueInst:
+      return copy.fromValue.lookThoughOwnershipInstructions
+    case let move as MoveValueInst:
+      return move.fromValue.lookThoughOwnershipInstructions
+    default:
+      return self
+    }
+  }
+
   /// Walks over all fields of an aggregate and checks if a reference count
   /// operation for this value is required. This differs from a simple `Type.isTrivial`
   /// check, because it treats a value_to_bridge_object instruction as "trivial".