[semantic-arc-opts] Implement @owned phi web elimination for phi webs with a single phi node that only have copy_value introducers.

This is the most simple initial version that I can commit. The hope is that this will help to bring this up in a nice way.

I am going to handle the multiple phi node and load [copy] case later to reduce
code churn.

<rdar://problem/56720436>

Author: gottesmm

include/swift/Basic/FrozenMultiMap.h

@@ -91,11 +91,17 @@ class FrozenMultiMap {
     frozen = true;
   }
 
+  /// Reset the frozen multimap in an unfrozen state with its storage cleared.
+  void reset() {
+    storage.clear();
+    frozen = false;
+  }
+
   unsigned size() const { return storage.size(); }
   bool empty() const { return storage.empty(); }
 
   struct iterator : std::iterator<std::forward_iterator_tag,
-                                  std::pair<Key, ArrayRef<Value>>> {
+                                  std::pair<Key, PairToSecondEltRange>> {
     using base_iterator = typename decltype(storage)::iterator;
 
     FrozenMultiMap &map;
@@ -159,9 +165,11 @@ class FrozenMultiMap {
     }
   };
 
+  using RangeType = llvm::iterator_range<iterator>;
+
   /// Return a range of (key, ArrayRef<Value>) pairs. The keys are guaranteed to
   /// be in key sorted order and the ArrayRef<Value> are in insertion order.
-  llvm::iterator_range<iterator> getRange() const {
+  RangeType getRange() const {
     assert(isFrozen() &&
            "Can not create range until data structure is frozen?!");
     auto *self = const_cast<FrozenMultiMap *>(this);

include/swift/SIL/OwnershipUtils.h

@@ -598,6 +598,28 @@ struct OwnedValueIntroducer {
     return OwnedValueIntroducer(value, *kind);
   }
 
+  /// Returns true if this owned introducer is able to be converted into a
+  /// guaranteed form if none of its uses are consuming uses (looking through
+  /// forwarding uses).
+  bool isConvertableToGuaranteed() const {
+    switch (kind) {
+    case OwnedValueIntroducerKind::Copy:
+    case OwnedValueIntroducerKind::LoadCopy:
+      return true;
+    case OwnedValueIntroducerKind::Apply:
+    case OwnedValueIntroducerKind::BeginApply:
+    case OwnedValueIntroducerKind::TryApply:
+    case OwnedValueIntroducerKind::LoadTake:
+    case OwnedValueIntroducerKind::Phi:
+    case OwnedValueIntroducerKind::FunctionArgument:
+    case OwnedValueIntroducerKind::PartialApplyInit:
+    case OwnedValueIntroducerKind::AllocBoxInit:
+    case OwnedValueIntroducerKind::AllocRefInit:
+      return false;
+    }
+    llvm_unreachable("Covered switch isn't covered?!");
+  }
+
   bool operator==(const OwnedValueIntroducer &other) const {
     return value == other.value;
   }