AliasAnalysis: a complete overhaul of alias- and memory-behavior analysis

The main changes are:

*) Rewrite everything in swift. So far, parts of memory-behavior analysis were already implemented in swift. Now everything is done in swift and lives in `AliasAnalysis.swift`. This is a big code simplification.

*) Support many more instructions in the memory-behavior analysis - especially OSSA instructions, like `begin_borrow`, `end_borrow`, `store_borrow`, `load_borrow`. The computation of end_borrow effects is now much more precise. Also, partial_apply is now handled more precisely.

*) Simplify and reduce type-based alias analysis (TBAA). The complexity of the old TBAA comes from old days where the language and SIL didn't have strict aliasing and exclusivity rules (e.g. for inout arguments). Now TBAA is only needed for code using unsafe pointers. The new TBAA handles this - and not more. Note that TBAA for classes is already done in `AccessBase.isDistinct`.

*) Handle aliasing in `begin_access [modify]` scopes. We already supported truly immutable scopes like `begin_access [read]` or `ref_element_addr [immutable]`. For `begin_access [modify]` we know that there are no other reads or writes to the access-address within the scope.

*) Don't cache memory-behavior results. It turned out that the hit-miss rate was pretty bad (~ 1:7). The overhead of the cache lookup took as long as recomputing the memory behavior.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -24,7 +24,7 @@ public struct CalleeAnalysis {
       },
       // getMemBehaviorFn
       { (bridgedApply: BridgedInstruction, observeRetains: Bool, bca: BridgedCalleeAnalysis) -> BridgedMemoryBehavior in
-        let apply = bridgedApply.instruction as! ApplySite
+        let apply = bridgedApply.instruction as! FullApplySite
         let e = bca.analysis.getSideEffects(ofApply: apply)
         return e.getMemBehavior(observeRetains: observeRetains)
       }
@@ -60,7 +60,7 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the global (i.e. not argument specific) side effects of an apply.
-  public func getSideEffects(ofApply apply: ApplySite) -> SideEffects.GlobalEffects {
+  public func getSideEffects(ofApply apply: FullApplySite) -> SideEffects.GlobalEffects {
     return getSideEffects(ofCallee: apply.callee)
   }
 
@@ -78,7 +78,7 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the argument specific side effects of an apply.
-  public func getSideEffects(of apply: ApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
+  public func getSideEffects(of apply: FullApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
     var result = SideEffects.GlobalEffects()
     guard let calleeArgIdx = apply.calleeArgumentIndex(of: operand) else {
       return result

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -258,11 +258,6 @@ struct FunctionPassContext : MutatingContext {
     SimplifyContext(_bridged: _bridged, notifyInstructionChanged: notifyInstructionChanged, preserveDebugInfo: preserveDebugInfo)
   }
 
-  var aliasAnalysis: AliasAnalysis {
-    let bridgedAA = _bridged.getAliasAnalysis()
-    return AliasAnalysis(bridged: bridgedAA)
-  }
-
   var deadEndBlocks: DeadEndBlocksAnalysis {
     let bridgeDEA = _bridged.getDeadEndBlocksAnalysis()
     return DeadEndBlocksAnalysis(bridged: bridgeDEA)

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -110,6 +110,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
 
   // Test passes
+  registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })
   registerPass(functionUsesDumper, { functionUsesDumper.run($0) })
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
   registerPass(escapeInfoDumper, { escapeInfoDumper.run($0) })

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -0,0 +1,60 @@
+//===--- AliasInfoDumper.swift --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 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
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+/// Prints the memory behavior of relevant instructions in relation to address values of the function.
+let aliasInfoDumper = FunctionPass(name: "dump-alias-info") {
+  (function: Function, context: FunctionPassContext) in
+
+  let aliasAnalysis = context.aliasAnalysis
+
+  print("@\(function.name)")
+
+  let values = function.allValues
+
+  var pair = 0
+  for (index1, value1) in values.enumerated() {
+    for (index2, value2) in values.enumerated() {
+      if index2 >= index1 {
+        let result = aliasAnalysis.mayAlias(value1, value2)
+        precondition(result == aliasAnalysis.mayAlias(value2, value1), "alias analysis not symmetric")
+
+        print("PAIR #\(pair).")
+        print("  \(value1)")
+        print("  \(value2)")
+        if result {
+          print("  MayAlias")
+        } else if !value1.uses.isEmpty && !value2.uses.isEmpty {
+          print("  NoAlias")
+        } else {
+          print("  noalias?")
+        }
+
+        pair += 1
+      }
+    }
+  }
+}
+
+private extension Function {
+  var allValues: [Value] {
+    var values: [Value] = []
+    for block in blocks {
+      values.append(contentsOf: block.arguments.map { $0 })
+      for inst in block.instructions {
+        values.append(contentsOf: inst.results)
+      }
+    }
+    return values
+  }
+}

SwiftCompilerSources/Sources/Optimizer/TestPasses/AliasInfoDumper.swift

@@ -9,6 +9,7 @@
 swift_compiler_sources(Optimizer
   FunctionUsesDumper.swift
   AccessDumper.swift
+  AliasInfoDumper.swift
   DeadEndBlockDumper.swift
   EscapeInfoDumper.swift
   MemBehaviorDumper.swift

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -109,9 +109,7 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info") {
   for value in valuesToCheck {
     print("value:\(value)")
     for apply in applies {
-      let path = AliasAnalysis.getPtrOrAddressPath(for: value)
-      
-      if value.at(path).isEscaping(using: Visitor(apply: apply), context) {
+      if value.allContainedAddresss.isEscaping(using: Visitor(apply: apply), context) {
         print("  ==> \(apply)")
       } else {
         print("  -   \(apply)")
@@ -129,8 +127,8 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info") {
         print(lhs)
         print(rhs)
 
-        let projLhs = lhs.at(AliasAnalysis.getPtrOrAddressPath(for: lhs))
-        let projRhs = rhs.at(AliasAnalysis.getPtrOrAddressPath(for: rhs))
+        let projLhs = lhs.allContainedAddresss
+        let projRhs = rhs.allContainedAddresss
         let mayAlias = projLhs.canAddressAlias(with: projRhs, context)
         if mayAlias != projRhs.canAddressAlias(with: projLhs, context) {
           fatalError("canAddressAlias(with:) must be symmetric")

SwiftCompilerSources/Sources/Optimizer/TestPasses/EscapeInfoDumper.swift

@@ -27,7 +27,7 @@ let memBehaviorDumper = FunctionPass(name: "dump-mem-behavior") {
 
     for value in values where value.definingInstruction != inst {
 
-      if value.type.isAddress || value is AddressToPointerInst {
+      if value.type.isAddress {
         let read = inst.mayRead(fromAddress: value, aliasAnalysis)
         let write = inst.mayWrite(toAddress: value, aliasAnalysis)
         print("PAIR #\(currentPair).")
@@ -57,21 +57,22 @@ private extension Function {
 private extension Instruction {
   var shouldTest: Bool {
     switch self {
-    case is ApplyInst,
-         is TryApplyInst,
+    case is ApplySite,
          is EndApplyInst,
-         is BeginApplyInst,
          is AbortApplyInst,
          is BeginAccessInst,
          is EndAccessInst,
          is EndCOWMutationInst,
          is CopyValueInst,
          is DestroyValueInst,
+         is IsUniqueInst,
          is EndBorrowInst,
          is LoadInst,
+         is LoadBorrowInst,
          is StoreInst,
          is CopyAddrInst,
          is BuiltinInst,
+         is StoreBorrowInst,
          is DebugValueInst:
       return true
     default:

SwiftCompilerSources/Sources/Optimizer/TestPasses/MemBehaviorDumper.swift

@@ -604,6 +604,10 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
       write = write || other.write
     }
 
+    public static var noEffects: Memory {
+      Memory(read: false, write: false)
+    }
+
     public static var worstEffects: Memory {
       Memory(read: true, write: true)
     }

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -202,6 +202,34 @@ extension Value {
   public func at(_ kind: SmallProjectionPath.FieldKind, index: Int = 0) -> ProjectedValue {
     ProjectedValue(value: self, path: SmallProjectionPath(kind, index: index))
   }
+
+  /// Projects all "contained" addresses of this value.
+  ///
+  /// If this value is an address, projects all sub-fields of the address, e.g. struct fields.
+  ///
+  /// If this value is not an address, projects all "interior" pointers of the value:
+  /// If this value is a class, "interior" pointer means: an address of any stored property of the class instance.
+  /// If this value is a struct or another value type, "interior" pointers refer to any stored propery addresses of
+  /// any class references in the struct or value type. For example:
+  ///
+  /// class C { var x: Int; var y: Int }
+  /// struct S { var c1: C; var c2: C }
+  /// let s: S
+  ///
+  /// `s.allContainedAddresss` refers to `s.c1.x`, `s.c1.y`, `s.c2.x` and `s.c2.y`
+  ///
+  public var allContainedAddresss: ProjectedValue {
+    if type.isAddress {
+      // This is the regular case: the path selects any sub-fields of an address.
+      return at(SmallProjectionPath(.anyValueFields))
+    }
+    if type.isClass {
+      // If the value is a (non-address) reference it means: all addresses within the class instance.
+      return at(SmallProjectionPath(.anyValueFields).push(.anyClassField))
+    }
+    // Any other non-address value means: all addresses of any referenced class instances within the value.
+    return at(SmallProjectionPath(.anyValueFields).push(.anyClassField).push(.anyValueFields))
+  }
 }