Swift AccessUtils: improvements and bug fixes

While I was using the new AccessUtils for a new optimization pass I discovered some areas for improvements. Also I found some bugs.

Changes:

* AccessBase: remove the unhealthy redundancy between `kind` and `baseAddress` types. Now AccessBase is single enum with the relevant base objects/addresses as payloads.

* AccessBase: for `global`, store the `GlobalValue` and not a `global_address` instruction, which is more accurate (because there can be multiple `global_addr`s for a single global variable)

* AccessBase: drop the support for function argument "pointers". The `pointer` is now always a `pointer_to_address` instruction. This also simplifies `PointerIdentification`: either it finds a matching `address_to_pointer` or it bails.

* AccessBase: improve `func isDistinct(from:)`. There are more possibilities to prove that two access bases do not alias.

* AccessBase: replace `var isUniquelyIdentified` with `var hasKnownStorageKind` which is more useful for aliasing checking.

* AccessPath: fix `func isDistinct(from:)`. `SmallProjectionPath.matches` is the wrong way to check if two expression paths may overlap. Instead use the new `SmallProjectionPath.mayOverlap`.

* AccessStoragePathWalker: rename `getAccessStorage` -> `visitAccessStorageRoots` and let it return false if it's not a class/reference AccessBase.

* add tests for `AccessPath.isDistinct(from:)`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AccessDumper.swift

@@ -10,25 +10,35 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Basic
 import SIL
 
 /// Dumps access information for memory accesses (`load` and `store`)
 /// instructions.
+/// Also verifies that `AccessPath.isDistinct(from:)` is correct. This does not actually
+/// dumps anything, but aborts if the result is wrong.
 ///
 /// This pass is used for testing `AccessUtils`.
 let accessDumper = FunctionPass(name: "dump-access", {
   (function: Function, context: PassContext) in
   print("Accesses for \(function.name)")
 
-  var apw = AccessPathWalker()
-  var arw = AccessStoragePathVisitor()
   for block in function.blocks {
     for instr in block.instructions {
       switch instr {
       case let st as StoreInst:
-        printAccessInfo(st.destinationOperand.value, &apw, &arw, context)
+        printAccessInfo(address: st.destination)
       case let load as LoadInst:
-        printAccessInfo(load.operand, &apw, &arw, context)
+        printAccessInfo(address: load.operand)
+      case let apply as ApplyInst:
+        guard let callee = apply.referencedFunction else {
+          break
+        }
+        if callee.name == "_isDistinct" {
+          checkAliasInfo(forArgumentsOf: apply, expectDistinct: true)
+        } else if callee.name == "_isNotDistinct" {
+          checkAliasInfo(forArgumentsOf: apply, expectDistinct: false)
+        }
       default:
         break
       }
@@ -46,10 +56,11 @@ private struct AccessStoragePathVisitor : AccessStoragePathWalker {
   }
 }
 
-private func printAccessInfo(_ value: Value, _ apw: inout AccessPathWalker, _ aspw: inout AccessStoragePathVisitor,
-                             _ ctx: PassContext) {
-  print("Value: \(value)")
-  let (ap, scope) = apw.getAccessPathWithScope(of: value)
+private func printAccessInfo(address: Value) {
+  print("Value: \(address)")
+
+  var apw = AccessPathWalker()
+  let (ap, scope) = apw.getAccessPathWithScope(of: address)
   if let scope = scope {
     switch scope {
     case let .scope(ba):
@@ -63,6 +74,30 @@ private func printAccessInfo(_ value: Value, _ apw: inout AccessPathWalker, _ as
     print("  Base: \(ap.base)")
     print("  Path: \"\(ap.projectionPath)\"")
 
-    aspw.getAccessStorage(for: ap)
+    var arw = AccessStoragePathVisitor()
+    if !arw.visitAccessStorageRoots(of: ap) {
+      print("   no Storage paths")
+    }
+  }
+}
+
+private func checkAliasInfo(forArgumentsOf apply: ApplyInst, expectDistinct: Bool) {
+  let address1 = apply.arguments[0]
+  let address2 = apply.arguments[1]
+  var apw = AccessPathWalker()
+  guard let path1 = apw.getAccessPath(of: address1),
+        let path2 = apw.getAccessPath(of: address2) else {
+    return
+  }
+  if path1.isDistinct(from: path2) != expectDistinct {
+    print("wrong isDistinct result of \(apply)")
+  } else if path2.isDistinct(from: path1) != expectDistinct {
+    print("wrong reverse isDistinct result of \(apply)")
+  } else {
+    return
   }
+  
+  print("in function")
+  print(apply.function)
+  fatalError()
 }