[semantic-arc-opts] Implement a simple load [copy] -> load_borrow optimization for arguments to create optimization scaffolding.

This is the first in a sequence of patches that implement various optimizations
to transform load [copy] into load_borrow.

The optimization works by looking for a load [copy] that:

1. Only has destroy_value as consuming users. This implies that we do not need
to pass off the in memory value at +1 and that we can use a +0 value.

2. Is loading from a memory location that is never written to or only written to
after all uses of the load [copy].

and then RAUW the load [copy] with a load_borrow and convertes the destroy_value
to end_borrow.

NOTE: I also a .def file for AccessedStorage so we can do visitors over the
kinds. The reason I want to do this is to ensure that people update these
optimizations if we add new storage kinds.

Author: gottesmm

include/swift/SIL/AccessedStorage.def

@@ -0,0 +1,39 @@
+//===--- AccessedStorage.def ----------------------------*- c++ -*---------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// A file used for metaprogramming with accessed storage. Used to enable
+/// easily updateable visitors.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef ACCESSED_STORAGE
+#error "Must define accesed storage before including this?!"
+#endif
+
+#ifndef ACCESSED_STORAGE_RANGE
+#define ACCESSED_STORAGE_RANGE(Name, Start, End)
+#endif
+
+ACCESSED_STORAGE(Box)
+ACCESSED_STORAGE(Stack)
+ACCESSED_STORAGE(Global)
+ACCESSED_STORAGE(Class)
+ACCESSED_STORAGE(Argument)
+ACCESSED_STORAGE(Yield)
+ACCESSED_STORAGE(Nested)
+ACCESSED_STORAGE(Unidentified)
+ACCESSED_STORAGE_RANGE(AccessedStorageKind, Box, Unidentified)
+
+#undef ACCESSED_STORAGE_RANGE
+#undef ACCESSED_STORAGE

include/swift/SIL/MemAccessUtils.h

@@ -106,15 +106,11 @@ class AccessedStorage {
   /// Enumerate over all valid begin_access bases. Clients can use a covered
   /// switch to warn if findAccessedAddressBase ever adds a case.
   enum Kind : uint8_t {
-    Box,
-    Stack,
-    Global,
-    Class,
-    Argument,
-    Yield,
-    Nested,
-    Unidentified,
-    NumKindBits = countBitsUsed(static_cast<unsigned>(Unidentified))
+#define ACCESSED_STORAGE(Name) Name,
+#define ACCESSED_STORAGE_RANGE(Name, Start, End)                               \
+  First_##Name = Start, Last_##Name = End,
+#include "swift/SIL/AccessedStorage.def"
+    NumKindBits = countBitsUsed(unsigned(Last_AccessedStorageKind))
   };
 
   static const char *getKindName(Kind k);
@@ -339,6 +335,26 @@ inline bool accessingIdenticalLocations(AccessedStorage LHS,
     return LHS.getObjectProjection() == RHS.getObjectProjection();
   }
 }
+
+template <class ImplTy, class ResultTy = void, typename... ArgTys>
+class AccessedStorageVisitor {
+  ImplTy &asImpl() { return static_cast<ImplTy &>(*this); }
+
+public:
+#define ACCESSED_STORAGE(Name)                                                 \
+  ResultTy visit##Name(const AccessedStorage &storage, ArgTys &&... args);
+#include "swift/SIL/AccessedStorage.def"
+
+  ResultTy visit(const AccessedStorage &storage, ArgTys &&... args) {
+    switch (storage.getKind()) {
+#define ACCESSED_STORAGE(Name)                                                 \
+  case AccessedStorage::Name:                                                  \
+    return asImpl().visit##Name(storage, std::forward<ArgTys>(args)...);
+#include "swift/SIL/AccessedStorage.def"
+    }
+  }
+};
+
 } // end namespace swift
 
 namespace llvm {

lib/SIL/MemAccessUtils.cpp

@@ -140,22 +140,10 @@ const ValueDecl *AccessedStorage::getDecl(SILFunction *F) const {
 
 const char *AccessedStorage::getKindName(AccessedStorage::Kind k) {
   switch (k) {
-  case Box:
-    return "Box";
-  case Stack:
-    return "Stack";
-  case Nested:
-    return "Nested";
-  case Unidentified:
-    return "Unidentified";
-  case Argument:
-    return "Argument";
-  case Yield:
-    return "Yield";
-  case Global:
-    return "Global";
-  case Class:
-    return "Class";
+#define ACCESSED_STORAGE(NAME)                                                 \
+  case AccessedStorage::NAME:                                                  \
+    return #NAME;
+#include "swift/SIL/AccessedStorage.def"
   }
   llvm_unreachable("unhandled kind");
 }

lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -13,8 +13,10 @@
 #define DEBUG_TYPE "sil-semantic-arc-opts"
 #include "swift/Basic/STLExtras.h"
 #include "swift/SIL/BasicBlockUtils.h"
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
@@ -27,6 +29,8 @@
 using namespace swift;
 
 STATISTIC(NumEliminatedInsts, "number of removed instructions");
+STATISTIC(NumLoadCopyConvertedToLoadBorrow,
+          "number of load_copy converted to load_borrow");
 
 //===----------------------------------------------------------------------===//
 //                                  Utility
@@ -75,6 +79,7 @@ struct SemanticARCOptVisitor
   bool visitSILInstruction(SILInstruction *i) { return false; }
   bool visitCopyValueInst(CopyValueInst *cvi);
   bool visitBeginBorrowInst(BeginBorrowInst *bbi);
+  bool visitLoadInst(LoadInst *li);
 };
 
 } // end anonymous namespace
@@ -245,6 +250,116 @@ bool SemanticARCOptVisitor::visitCopyValueInst(CopyValueInst *cvi) {
   return false;
 }
 
+//===----------------------------------------------------------------------===//
+//                         load [copy] Optimizations
+//===----------------------------------------------------------------------===//
+
+/// A flow insensitive analysis that tells the load [copy] analysis if the
+/// storage has 0, 1, >1 writes to it.
+///
+/// In the case of 0 writes, we return CanOptimizeLoadCopyResult::Always.
+///
+/// In the case of 1 write, we return OnlyIfStorageIsLocal. We are taking
+/// advantage of definite initialization implying that an alloc_stack must be
+/// written to once before any loads from the memory location. Thus if we are
+/// local and see 1 write, we can still change to load_borrow if all other uses
+/// check out.
+///
+/// If there is 2+ writes, we can not optimize = (.
+namespace {
+
+struct CanOptimizeLoadCopyFromAccessVisitor
+    : AccessedStorageVisitor<CanOptimizeLoadCopyFromAccessVisitor, bool> {
+  SILFunction &f;
+
+  CanOptimizeLoadCopyFromAccessVisitor(SILFunction &f) : f(f) {}
+
+  // Stubs
+  bool visitBox(const AccessedStorage &boxStorage) { return false; }
+  bool visitStack(const AccessedStorage &stackStorage) { return false; }
+  bool visitGlobal(const AccessedStorage &globalStorage) { return false; }
+  bool visitClass(const AccessedStorage &classStorage) { return false; }
+  bool visitYield(const AccessedStorage &yieldStorage) { return false; }
+  bool visitUnidentified(const AccessedStorage &unidentifiedStorage) {
+    return false;
+  }
+  bool visitNested(const AccessedStorage &nested) {
+    llvm_unreachable("Visitor should never see nested since we lookup our "
+                     "address storage using lookup non nested");
+  }
+
+  bool visitArgument(const AccessedStorage &argumentStorage);
+};
+
+} // namespace
+
+bool CanOptimizeLoadCopyFromAccessVisitor::visitArgument(
+    const AccessedStorage &storage) {
+  auto *arg = cast<SILFunctionArgument>(storage.getArgument(&f));
+
+  // Then check if we have an in_guaranteed argument. In this case, we can
+  // always optimize load [copy] from this.
+  if (arg->hasConvention(SILArgumentConvention::Indirect_In_Guaranteed))
+    return true;
+
+  // For now just return false.
+  return false;
+}
+
+static bool isWrittenTo(SILFunction &f, SILValue value) {
+  // Then find our accessed storage. If we can not find anything, be
+  // conservative and assume that the value is written to.
+  const auto &storage = findAccessedStorageNonNested(value);
+  if (!storage)
+    return false;
+
+  // Then see if we ever write to this address in a flow insensitive
+  // way (ignoring stores that are obviously the only initializer to
+  // memory). We have to do this since load_borrow assumes that the
+  // underlying memory is never written to.
+  return !CanOptimizeLoadCopyFromAccessVisitor(f).visit(storage);
+}
+
+// Convert a load [copy] from unique storage [read] that has all uses that can
+// accept a guaranteed parameter to a load_borrow.
+bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
+  if (li->getOwnershipQualifier() != LoadOwnershipQualifier::Copy)
+    return false;
+
+  // Ok, we have our load [copy]. Make sure its value is never
+  // consumed. If it is consumed, we need to pass off a +1 value, so
+  // bail.
+  //
+  // FIXME: We should consider if it is worth promoting a load [copy]
+  // -> load_borrow if we can put a copy_value on a cold path and thus
+  // eliminate RR traffic on a hot path.
+  SmallVector<DestroyValueInst *, 32> destroyValues;
+  if (isConsumed(li, destroyValues))
+    return false;
+
+  // Then check if our address is ever written to. If it is, then we
+  // can not use the load_borrow.
+  if (isWrittenTo(*li->getFunction(), li->getOperand()))
+    return false;
+
+  // Ok, we can perform our optimization. Convert the load [copy] into a
+  // load_borrow.
+  auto *lbi =
+      SILBuilderWithScope(li).createLoadBorrow(li->getLoc(), li->getOperand());
+  while (!destroyValues.empty()) {
+    auto *dvi = destroyValues.pop_back_val();
+    SILBuilderWithScope(dvi).createEndBorrow(dvi->getLoc(), lbi);
+    dvi->eraseFromParent();
+    ++NumEliminatedInsts;
+  }
+
+  li->replaceAllUsesWith(lbi);
+  li->eraseFromParent();
+  ++NumEliminatedInsts;
+  ++NumLoadCopyConvertedToLoadBorrow;
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //                            Top Level Entrypoint
 //===----------------------------------------------------------------------===//

test/SILOptimizer/semantic-arc-opts.sil

@@ -239,3 +239,40 @@ bb3:
   %9999 = tuple()
   return %9999 : $()
 }
+
+// Simple in_guaranteed argument load_copy.
+// CHECK-LABEL: sil @load_copy_from_in_guaranteed : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK: load_borrow
+// CHECK: load_borrow
+// CHECK: load [copy]
+// CHECK: } // end sil function 'load_copy_from_in_guaranteed'
+sil @load_copy_from_in_guaranteed : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $*Builtin.NativeObject):
+  %g = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  // Simple same bb.
+  %1 = load [copy] %0 : $*Builtin.NativeObject
+  apply %g(%1) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  destroy_value %1 : $Builtin.NativeObject
+
+  // Diamond.
+  %2 = load [copy] %0 : $*Builtin.NativeObject
+  cond_br undef, bb1, bb2
+
+bb1:
+  apply %g(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  destroy_value %2 : $Builtin.NativeObject
+  br bb3
+
+bb2:
+  destroy_value %2 : $Builtin.NativeObject
+  br bb3
+
+bb3:
+  // Consuming use blocks.
+  %3 = load [copy] %0 : $*Builtin.NativeObject
+  %4 = function_ref @owned_user : $@convention(thin) (@owned Builtin.NativeObject) -> ()
+  apply %4(%3) : $@convention(thin) (@owned Builtin.NativeObject) -> ()
+  %9999 = tuple()
+  return %9999 : $()
+}