Prevent begin_borrow on addresses and cleanup address access utils.

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -53,6 +53,14 @@ namespace swift {
 /// (pointer-to-address is not stripped).
 SILValue stripAccessMarkers(SILValue v);
 
+/// Return a non-null address-type SingleValueInstruction if \p v is the result
+/// of an address projection that may be inside of a formal access, such as
+/// (begin_borrow, struct_element_addr, tuple_element_addr).
+///
+/// The resulting projection must have an address-type operand at index zero
+/// representing the projected address.
+SingleValueInstruction *isAccessProjection(SILValue v);
+
 /// Attempt to return the address corresponding to a variable's formal access
 /// by stripping indexing and address projections.
 ///

include/swift/SIL/SILBuilder.h

@@ -728,6 +728,7 @@ class SILBuilder {
   }
 
   BeginBorrowInst *createBeginBorrow(SILLocation Loc, SILValue LV) {
+    assert(!LV->getType().isAddress());
     return insert(new (getModule())
                       BeginBorrowInst(getSILDebugLocation(Loc), LV));
   }

lib/SIL/MemAccessUtils.cpp

@@ -22,37 +22,39 @@
 using namespace swift;
 
 SILValue swift::stripAccessMarkers(SILValue v) {
-  while (true) {
-    switch (v->getKind()) {
-    default:
-      return v;
-
-    case ValueKind::BeginBorrowInst:
-    case ValueKind::BeginAccessInst:
-      v = cast<SingleValueInstruction>(v)->getOperand(0);
-    }
+  while (auto *bai = dyn_cast<BeginAccessInst>(v)) {
+    v = bai->getOperand();
   }
+  return v;
+}
+
+// The resulting projection must have an address-type operand at index zero
+// representing the projected address.
+SingleValueInstruction *swift::isAccessProjection(SILValue v) {
+  switch (v->getKind()) {
+  default:
+    return nullptr;
+
+  case ValueKind::StructElementAddrInst:
+  case ValueKind::TupleElementAddrInst:
+  case ValueKind::UncheckedTakeEnumDataAddrInst:
+  case ValueKind::TailAddrInst:
+  case ValueKind::IndexAddrInst:
+    return cast<SingleValueInstruction>(v);
+  };
 }
 
 // TODO: When the optimizer stops stripping begin_access markers, then we should
 // be able to assert that the result is a BeginAccessInst and the default case
 // is unreachable.
 SILValue swift::getAccessedAddress(SILValue v) {
-  assert(v->getType().isAddress());
   while (true) {
-    switch (v->getKind()) {
-    default:
+    assert(v->getType().isAddress());
+    auto *projection = isAccessProjection(v);
+    if (!projection)
       return v;
 
-    case ValueKind::BeginBorrowInst:
-    case ValueKind::StructElementAddrInst:
-    case ValueKind::TupleElementAddrInst:
-    case ValueKind::UncheckedTakeEnumDataAddrInst:
-    case ValueKind::TailAddrInst:
-    case ValueKind::IndexAddrInst:
-      v = cast<SingleValueInstruction>(v)->getOperand(0);
-      continue;
-    };
+    v = projection->getOperand(0);
   }
 }