Add a UniqueAddressUses utility.

Analyze and classify the leaf uses of unique storage.

Storage that has a unique set of roots within this function includes
alloc_stack, alloc_box, exclusive argument, and global variables. All access
to the storage within this function is derived from these roots.

Gather the kinds of uses that are typically relevant to algorithms:
- loads	      (including copies out of, not including inout args)
- stores      (including copies into and inout args)
- destroys    (of the entire aggregate)
- debugUses   (only populated when preserveDebugInfo == false)

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -1324,6 +1324,45 @@ bool visitAccessPathUses(AccessUseVisitor &visitor, AccessPath accessPath,
 
 } // end namespace swift
 
+//===----------------------------------------------------------------------===//
+//                      MARK: UniqueAddressUses
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+
+/// Analyze and classify the leaf uses of unique storage.
+///
+/// Storage that has a unique set of roots within this function includes
+/// alloc_stack, alloc_box, exclusive argument, and global variables. All access
+/// to the storage within this function is derived from these roots.
+///
+/// Gather the kinds of uses that are typically relevant to algorithms:
+/// - loads       (including copies out of, not including inout args)
+/// - stores      (including copies into and inout args)
+/// - destroys    (of the entire aggregate)
+/// - debugUses   (only populated when preserveDebugInfo == false)
+/// - unknownUses (e.g. address_to_pointer, box escape)
+struct UniqueStorageUseVisitor {
+  static bool findUses(UniqueStorageUseVisitor &visitor);
+
+  SILFunction *function;
+  AccessStorage storage;
+
+  UniqueStorageUseVisitor(AccessStorage storage, SILFunction *function)
+      : function(function), storage(storage) {}
+
+  virtual ~UniqueStorageUseVisitor() = default;
+
+  virtual bool visitLoad(Operand *use) = 0;
+  virtual bool visitStore(Operand *use) = 0;
+  virtual bool visitDestroy(Operand *use) = 0;
+  virtual bool visitDealloc(Operand *use) = 0;
+  virtual bool visitDebugUse(Operand *use) = 0;
+  virtual bool visitUnknownUse(Operand *use) = 0;
+};
+
+} // namespace swift
+
 //===----------------------------------------------------------------------===//
 //             MARK: Helper API for specific formal access patterns
 //===----------------------------------------------------------------------===//

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1923,6 +1923,110 @@ bool AccessPath::collectUses(SmallVectorImpl<Operand *> &uses,
   return visitAccessPathUses(collector, *this, function);
 }
 
+//===----------------------------------------------------------------------===//
+//                      MARK: UniqueStorageUseVisitor
+//===----------------------------------------------------------------------===//
+
+struct GatherUniqueStorageUses : public AccessUseVisitor {
+  UniqueStorageUseVisitor &visitor;
+
+  GatherUniqueStorageUses(UniqueStorageUseVisitor &visitor)
+      : AccessUseVisitor(AccessUseType::Overlapping,
+                         NestedAccessType::IgnoreAccessBegin),
+        visitor(visitor) {}
+
+  bool visitUse(Operand *use, AccessUseType useTy) override;
+};
+
+bool UniqueStorageUseVisitor::findUses(UniqueStorageUseVisitor &visitor) {
+  assert(visitor.storage.isUniquelyIdentified());
+
+  GatherUniqueStorageUses gather(visitor);
+  return visitAccessStorageUses(gather, visitor.storage, visitor.function);
+}
+
+bool GatherUniqueStorageUses::visitUse(Operand *use, AccessUseType useTy) {
+  unsigned operIdx = use->getOperandNumber();
+  auto *user = use->getUser();
+  assert(!user->isTypeDependentOperand(*use));
+
+  // TODO: handle non-escaping partial-applies just like a full apply. The
+  // address uses are the points where the partial apply is invoked.
+  if (FullApplySite apply = FullApplySite::isa(user)) {
+    switch (apply.getArgumentConvention(*use)) {
+    case SILArgumentConvention::Indirect_Inout:
+    case SILArgumentConvention::Indirect_InoutAliasable:
+    case SILArgumentConvention::Indirect_Out:
+      visitor.visitStore(use);
+      break;
+    case SILArgumentConvention::Indirect_In_Guaranteed:
+    case SILArgumentConvention::Indirect_In:
+    case SILArgumentConvention::Indirect_In_Constant:
+      visitor.visitLoad(use);
+      break;
+    case SILArgumentConvention::Direct_Unowned:
+    case SILArgumentConvention::Direct_Owned:
+    case SILArgumentConvention::Direct_Guaranteed:
+      // most likely an escape of a box
+      visitor.visitUnknownUse(use);
+      break;
+    }
+    return true;
+  }
+  switch (user->getKind()) {
+  case SILInstructionKind::DestroyAddrInst:
+  case SILInstructionKind::DestroyValueInst:
+    if (useTy == AccessUseType::Exact) {
+      visitor.visitDestroy(use);
+      return true;
+    }
+    visitor.visitUnknownUse(use);
+    return true;
+
+  case SILInstructionKind::DebugValueInst:
+    visitor.visitDebugUse(use);
+    return true;
+
+  case SILInstructionKind::LoadInst:
+  case SILInstructionKind::LoadWeakInst:
+  case SILInstructionKind::LoadUnownedInst:
+  case SILInstructionKind::ExistentialMetatypeInst:
+    visitor.visitLoad(use);
+    return true;
+
+  case SILInstructionKind::StoreInst:
+  case SILInstructionKind::StoreWeakInst:
+  case SILInstructionKind::StoreUnownedInst:
+    if (operIdx == CopyLikeInstruction::Dest) {
+      visitor.visitStore(use);
+      return true;
+    }
+    break;
+
+  case SILInstructionKind::InjectEnumAddrInst:
+    visitor.visitStore(use);
+    return true;
+
+  case SILInstructionKind::CopyAddrInst:
+    if (operIdx == CopyLikeInstruction::Dest) {
+      visitor.visitStore(use);
+      return true;
+    }
+    assert(operIdx == CopyLikeInstruction::Src);
+    visitor.visitLoad(use);
+    return true;
+
+  case SILInstructionKind::DeallocStackInst:
+    visitor.visitDealloc(use);
+    return true;
+
+  default:
+    break;
+  }
+  visitor.visitUnknownUse(use);
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //             MARK: Helper API for specific formal access patterns
 //===----------------------------------------------------------------------===//