Add an AccessPath abstraction and formalize memory access

Things that have come up recently but are somewhat blocked on this:

- Moving AccessMarkerElimination down in the pipeline
- SemanticARCOpts correctness and improvements
- AliasAnalysis improvements
- LICM performance regressions
- RLE/DSE improvements

Begin to formalize the model for valid memory access in SIL. Ignoring
ownership, every access is a def-use chain in three parts:

object root -> formal access base -> memory operation address

AccessPath abstracts over this path and standardizes the identity of a
memory access throughout the optimizer. This abstraction is the basis
for a new AccessPathVerification.

With that verification, we now have all the properties we need for the
type of analysis requires for exclusivity enforcement, but now
generalized for any memory analysis. This is suitable for an extremely
lightweight analysis with no side data structures. We currently have a
massive amount of ad-hoc memory analysis throughout SIL, which is
incredibly unmaintainable, bug-prone, and not performance-robust. We
can begin taking advantage of this verifably complete model to solve
that problem.

The properties this gives us are:

Access analysis must be complete over memory operations: every memory
operation needs a recognizable valid access. An access can be
unidentified only to the extent that it is rooted in some non-address
type and we can prove that it is at least *not* part of an access to a
nominal class or global property. Pointer provenance is also required
for future IRGen-level bitfield optimizations.

Access analysis must be complete over address users: for an identified
object root all memory accesses including subobjects must be
discoverable.

Access analysis must be symmetric: use-def and def-use analysis must
be consistent.

AccessPath is merely a wrapper around the existing accessed-storage
utilities and IndexTrieNode. Existing passes already very succesfully
use this approach, but in an ad-hoc way. With a general utility we
can:

- update passes to use this approach to identify memory access,
  reducing the space and time complexity of those algorithms.

- implement an inexpensive on-the-fly, debug mode address lifetime analysis

- implement a lightweight debug mode alias analysis

- ultimately improve the power, efficiency, and maintainability of
  full alias analysis

- make our type-based alias analysis sensistive to the access path

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -668,6 +668,16 @@ using BuiltinApplyTy = typename Apply_match<BuiltinValueKind, Tys...>::Ty;
 // Define matchers for most of builtin instructions.
 #include "swift/AST/Builtins.def"
 
+#undef BUILTIN_UNARY_OP_MATCH_WITH_ARG_MATCHER
+#undef BUILTIN_BINARY_OP_MATCH_WITH_ARG_MATCHER
+#undef BUILTIN_VARARGS_OP_MATCH_WITH_ARG_MATCHER
+#undef BUILTIN_CAST_OPERATION
+#undef BUILTIN_CAST_OR_BITCAST_OPERATION
+#undef BUILTIN_BINARY_OPERATION_ALL
+#undef BUILTIN_BINARY_PREDICATE
+#undef BUILTIN_MISC_OPERATION
+#undef BUILTIN
+
 //===
 // Convenience compound builtin instructions matchers that succeed
 // if any of the sub-matchers succeed.

include/swift/SIL/PatternMatch.h

@@ -39,8 +39,8 @@ bool pointsToLocalObject(SILValue V);
 /// Returns true if \p V is a uniquely identified address or reference. Two
 /// uniquely identified pointers with distinct roots cannot alias. However, a
 /// uniquely identified pointer may alias with unidentified pointers. For
-/// example, the uniquely identified pointer may escape to a call that returns an
-/// alias of that pointer.
+/// example, the uniquely identified pointer may escape to a call that returns
+/// an alias of that pointer.
 ///
 /// It may be any of:
 ///
@@ -53,14 +53,17 @@ bool pointsToLocalObject(SILValue V);
 ///
 /// - an address projection based on an exclusive argument with no levels of
 /// indirection (e.g. ref_element_addr, project_box, etc.).
+///
+/// TODO: Fold this into the AccessedStorage API. pointsToLocalObject should be
+/// performed by AccessedStorage::isUniquelyIdentified.
 inline bool isUniquelyIdentified(SILValue V) {
   SILValue objectRef = V;
   if (V->getType().isAddress()) {
     auto storage = findAccessedStorage(V);
     if (!storage)
       return false;
 
-    if (storage.isUniquelyIdentifiedAfterEnforcement())
+    if (storage.isUniquelyIdentified())
       return true;
 
     if (!storage.isObjectAccess())

include/swift/SILOptimizer/Analysis/ValueTracking.h

@@ -4125,7 +4125,7 @@ void IRGenSILFunction::visitRefTailAddrInst(RefTailAddrInst *i) {
 }
 
 static bool isInvariantAddress(SILValue v) {
-  SILValue accessedAddress = getAccessedAddress(v);
+  SILValue accessedAddress = getAccessAddress(v);
   if (auto *ptrRoot = dyn_cast<PointerToAddressInst>(accessedAddress)) {
     return ptrRoot->isInvariant();
   }