Merge pull request #75505 from eeckstein/alias-analysis

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

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

@@ -164,7 +164,7 @@ struct InstructionSet : IntrusiveSet {
     var d = "{\n"
     for inst in function.instructions {
       if contains(inst) {
-        d += inst.description
+        d += inst.description + "\n"
       }
     }
     d += "}\n"

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -76,3 +76,21 @@ typealias BasicBlockWorklist = Worklist<BasicBlockSet>
 typealias InstructionWorklist = Worklist<InstructionSet>
 typealias ValueWorklist = Worklist<ValueSet>
 typealias OperandWorklist = Worklist<OperandSet>
+
+extension InstructionWorklist {
+  mutating func pushPredecessors(of inst: Instruction, ignoring ignoreInst: SingleValueInstruction) {
+    if let prev = inst.previous {
+      if prev != ignoreInst {
+        pushIfNotVisited(prev)
+      }
+    } else {
+      for predBlock in inst.parentBlock.predecessors {
+        let termInst = predBlock.terminator
+        if termInst != ignoreInst {
+          pushIfNotVisited(termInst)
+        }
+      }
+    }
+  }
+}
+

SwiftCompilerSources/Sources/Optimizer/DataStructures/Worklist.swift

@@ -47,8 +47,10 @@ let computeEscapeEffects = FunctionPass(name: "compute-escape-effects") {
     }
 
     // First check: is the argument (or a projected value of it) escaping at all?
-    if !arg.at(.anything).isEscapingWhenWalkingDown(using: IgnoreRecursiveCallVisitor(),
-                                                    context) {
+    if !arg.at(.anything).isEscaping(using: IgnoreRecursiveCallVisitor(),
+                                     initialWalkingDirection: .down,
+                                     context)
+    {
       let effect = EscapeEffects.ArgumentEffect(.notEscaping, argumentIndex: arg.index,
                                                 pathPattern: SmallProjectionPath(.anything))
       newEffects.append(effect)
@@ -84,7 +86,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   // containing one or more references.
   let argPath = arg.type.isClass ? ap : ap.push(.anyValueFields)
 
-  guard let result = arg.at(argPath).visitByWalkingDown(using: ArgEffectsVisitor(), context) else {
+  guard let result = arg.at(argPath).visit(using: ArgEffectsVisitor(), initialWalkingDirection: .down, context) else {
     return false
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -544,6 +544,6 @@ private extension PartialApplyInst {
       var followTrivialTypes: Bool { true }
     }
 
-    return self.isEscapingWhenWalkingDown(using: EscapesToApply(), context)
+    return self.isEscaping(using: EscapesToApply(), initialWalkingDirection: .down, context)
   }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -200,7 +200,7 @@ private extension BuiltinInst {
       return
     }
 
-    let instanceType = type.instanceTypeOfMetatype(in: parentFunction)
+    let instanceType = type.loweredInstanceTypeOfMetatype(in: parentFunction)
     let builder = Builder(before: self, context)
     let newMetatype = builder.createMetatype(of: instanceType, representation: .Thin)
     operands[argument].set(to: newMetatype, context)
@@ -277,16 +277,21 @@ private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Func
   if lhsMetatype.isDynamicSelfMetatype != rhsMetatype.isDynamicSelfMetatype {
     return nil
   }
-  let lhsTy = lhsMetatype.instanceTypeOfMetatype(in: function)
-  let rhsTy = rhsMetatype.instanceTypeOfMetatype(in: function)
+  let lhsTy = lhsMetatype.loweredInstanceTypeOfMetatype(in: function)
+  let rhsTy = rhsMetatype.loweredInstanceTypeOfMetatype(in: function)
 
   // Do we know the exact types? This is not the case e.g. if a type is passed as metatype
   // to the function.
   let typesAreExact = lhsExistential.metatype is MetatypeInst &&
                       rhsExistential.metatype is MetatypeInst
 
   if typesAreExact {
-    if lhsTy == rhsTy {
+    // We need to compare the not lowered types, because function types may differ in their original version
+    // but are equal in the lowered version, e.g.
+    //   ((Int, Int) -> ())
+    //   (((Int, Int)) -> ())
+    //
+    if lhsMetatype == rhsMetatype {
       return true
     }
     // Comparing types of different classes which are in a sub-class relation is not handled by the

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.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
+  }
+}