Use the new EscapeInfo in AliasAnalysis

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -60,4 +60,108 @@ struct AliasAnalysis {
     // Any other non-address value means: all addresses of any referenced class instances within the value.
     return EscapeInfo.Path(.anyValueFields).push(.anyClassField).push(.anyValueFields)
   }
+  
+  static func register() {
+    AliasAnalysis_register(
+      // initFn
+      { (buffer: UnsafeMutableRawPointer, size: Int, ca: BridgedCalleeAnalysis) in
+        precondition(MemoryLayout<EscapeInfo>.size <= size, "wrong EscapeInfo size")
+        let ei = EscapeInfo(calleeAnalysis: CalleeAnalysis(bridged: ca))
+        buffer.initializeMemory(as: EscapeInfo.self, repeating: ei, count: 1)
+      },
+      // destroyFn
+      { (buffer: UnsafeMutableRawPointer, size: Int) in
+        precondition(MemoryLayout<EscapeInfo>.size <= size, "wrong EscapeInfo size")
+        buffer.assumingMemoryBound(to: EscapeInfo.self).deinitialize(count: 1)
+      },
+      // isAddrEscaping2InstFn
+      { (buffer: UnsafeMutableRawPointer, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction,
+         readingOpsMask: UInt64, writingOpsMask: UInt64) -> BridgedMemoryBehavior in
+        let eiPointer = buffer.assumingMemoryBound(to: EscapeInfo.self)
+        let inst = bridgedInst.instruction
+        let val = bridgedVal.value
+        let path = AliasAnalysis.getPtrOrAddressPath(for: val)
+        var isReading = false
+        var isWriting = false
+        if eiPointer.pointee.isEscaping(addressesOf: val, path: path,
+            visitUse: { op, _, _ in
+              let user = op.instruction
+              if user == inst {
+                let opIdx = op.index
+                if opIdx >= 64 || (readingOpsMask & (UInt64(1) << opIdx)) != 0 {
+                  isReading = true
+                }
+                if opIdx >= 64 || (writingOpsMask & (UInt64(1) << opIdx)) != 0 {
+                  isWriting = true
+                }
+              }
+              if user is ReturnInst {
+                // Anything which is returned cannot escape to an instruction inside the function.
+                return .ignore
+              }
+              return .continueWalking
+            }) {
+          return MayReadWriteBehavior
+        }
+        switch (isReading, isWriting) {
+          case (false, false): return NoneBehavior
+          case (true, false):  return MayReadBehavior
+          case (false, true):  return MayWriteBehavior
+          case (true, true):   return MayReadWriteBehavior
+        }
+      },
+      // isObjEscaping2InstFn
+      { (buffer: UnsafeMutableRawPointer, bridgedObj: BridgedValue, bridgedInst: BridgedInstruction,
+         operandMask: UInt64) -> Int in
+        let eiPointer = buffer.assumingMemoryBound(to: EscapeInfo.self)
+        let inst = bridgedInst.instruction
+        let obj = bridgedObj.value
+        let path = EscapeInfo.Path(.anyValueFields)
+        return eiPointer.pointee.isEscaping(object: obj, path: path,
+          visitUse: { op, _, _ in
+            let user = op.instruction
+            if user == inst {
+              let opIdx = op.index
+              if opIdx >= 64 || (operandMask & (UInt64(1) << opIdx)) != 0 {
+                return .markEscaping
+              }
+            }
+            if user is ReturnInst {
+              // Anything which is returned cannot escape to an instruction inside the function.
+              return .ignore
+            }
+            return .continueWalking
+          }) ? 1 : 0
+      },
+      // isAddrVisibleFromObj
+      { (buffer: UnsafeMutableRawPointer, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Int in
+        let eiPointer = buffer.assumingMemoryBound(to: EscapeInfo.self)
+        let addr = bridgedAddr.value
+        let obj = bridgedObj.value
+      
+        // Is the `addr` within all reachable objects/addresses, when start walking from `obj`?
+        // Try both directions: 1. from addr -> obj
+        return eiPointer.pointee.isEscaping(addressesOf: addr, path: EscapeInfo.Path(.anyValueFields),
+            visitUse: { op, _, _ in
+              if op.value == obj {
+                return .markEscaping
+              }
+              if op.instruction is ReturnInst {
+                // Anything which is returned cannot escape to an instruction inside the function.
+                return .ignore
+              }
+              return .continueWalking
+            }) ? 1 : 0
+      },
+      // canReferenceSameFieldFn
+      { (buffer: UnsafeMutableRawPointer, bridgedLhs: BridgedValue, bridgedRhs: BridgedValue) -> Int in
+        let eiPointer = buffer.assumingMemoryBound(to: EscapeInfo.self)
+        let lhs = bridgedLhs.value
+        let rhs = bridgedRhs.value
+        return eiPointer.pointee.canReferenceSameField(
+          lhs, path: AliasAnalysis.getPtrOrAddressPath(for: lhs),
+          rhs, path: AliasAnalysis.getPtrOrAddressPath(for: rhs)) ? 1 : 0
+      }
+    )
+  }
 }

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -20,6 +20,7 @@ import _CompilerRegexParser
 @_cdecl("initializeSwiftModules")
 public func initializeSwiftModules() {
   registerSILClasses()
+  registerAnalysis()
   registerSwiftPasses()
 
   #if canImport(_CompilerRegexParser)
@@ -43,6 +44,10 @@ private func registerPass<InstType: Instruction>(
   }
 }
 
+private func registerAnalysis() {
+  AliasAnalysis.register()
+}
+
 private func registerSwiftPasses() {
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -16,7 +16,7 @@ import SILBridging
 public struct Operand : CustomStringConvertible, CustomReflectable {
   fileprivate let bridged: BridgedOperand
 
-  init(_ bridged: BridgedOperand) {
+  public init(_ bridged: BridgedOperand) {
     self.bridged = bridged
   }
 

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -21,7 +21,6 @@
 namespace swift {
 
 class SideEffectAnalysis;
-class EscapeAnalysis;
 
 /// This class is a simple wrapper around an alias analysis cache. This is
 /// needed since we do not have an "analysis" infrastructure.
@@ -75,7 +74,8 @@ class AliasAnalysis {
   using TBAACacheKey = std::pair<SILType, SILType>;
 
   SideEffectAnalysis *SEA;
-  EscapeAnalysis *EA;
+
+  void *escapeInfoBuffer[6];
 
   /// A cache for the computation of TBAA. True means that the types may
   /// alias. False means that the types must not alias.
@@ -125,8 +125,9 @@ class AliasAnalysis {
   bool isInImmutableScope(SILInstruction *inst, SILValue V);
 
 public:
-  AliasAnalysis(SideEffectAnalysis *SEA, EscapeAnalysis *EA)
-    : SEA(SEA), EA(EA) {}
+  AliasAnalysis(SideEffectAnalysis *SEA);
+
+  ~AliasAnalysis();
 
   static SILAnalysisKind getAnalysisKind() { return SILAnalysisKind::Alias; }
 
@@ -158,11 +159,6 @@ class AliasAnalysis {
     return alias(V1, V2, TBAAType1, TBAAType2) == AliasResult::MayAlias;
   }
 
-  /// \returns True if the release of the \p releasedReference can access or
-  /// free memory accessed by \p User.
-  bool mayValueReleaseInterfereWithInstruction(SILInstruction *User,
-                                               SILValue releasedReference);
-
   /// Use the alias analysis to determine the memory behavior of Inst with
   /// respect to V.
   MemoryBehavior computeMemoryBehavior(SILInstruction *Inst, SILValue V);
@@ -206,6 +202,22 @@ class AliasAnalysis {
 
   /// Returns true if \p Ptr may be released by the builtin \p BI.
   bool canBuiltinDecrementRefCount(BuiltinInst *BI, SILValue Ptr);
+
+  /// Returns true if the address(es of) `addr` can escape to `toInst`.
+  MemoryBehavior getAddressEscapingBehavior(SILValue addr, SILInstruction *toInst,
+                         uint64_t readingOpsMask = ~uint64_t(0),
+                         uint64_t writingOpsMask = ~uint64_t(0));
+
+  /// Returns true if the object(s of) `obj` can escape to `toInst`.
+  bool isObjectEscaping(SILValue obj, SILInstruction *toInst,
+                        uint64_t operandMask = ~uint64_t(0));
+
+  /// Is the `addr` within all reachable objects/addresses, when start walking
+  /// from `obj`?
+  bool isAddrVisibleFromObject(SILValue addr, SILValue obj);
+
+  /// Returns true if `lhs` can reference the same field as `rhs`.
+  bool canReferenceSameField(SILValue lhs, SILValue rhs);
 };
 
 

include/swift/SILOptimizer/Analysis/SideEffectAnalysis.h

@@ -113,6 +113,8 @@ class GenericFunctionEffectAnalysis : public BottomUpIPAnalysis {
     getCalleeEffects(calleeEffects, fullApply);
     callEffects.mergeFromApply(calleeEffects, fullApply);
   }
+  
+  BasicCalleeAnalysis *getBasicCalleeAnalysis() { return BCA; }
 
   virtual void initialize(SILPassManager *PM) override;
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -15,6 +15,8 @@
 
 #include "swift/SIL/SILBridging.h"
 
+#include <stdint.h>
+
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 #ifdef __cplusplus
@@ -121,6 +123,23 @@ SwiftInt PostDominatorTree_postDominates(BridgedPostDomTree pdomTree,
                                          BridgedBasicBlock dominating,
                                          BridgedBasicBlock dominated);
 
+typedef void (* _Nonnull AliasAnalysisInitFn)(void * _Nonnull, SwiftInt,
+                                              BridgedCalleeAnalysis);
+typedef void (* _Nonnull AliasAnalysisDestroyFn)(void * _Nonnull, SwiftInt);
+typedef BridgedMemoryBehavior (* _Nonnull AliasAnalysisAddr2InstFn)(
+      void * _Nonnull, BridgedValue, BridgedInstruction, uint64_t, uint64_t);
+typedef SwiftInt (* _Nonnull AliasAnalysisEscaping2InstFn)(
+      void * _Nonnull, BridgedValue, BridgedInstruction, uint64_t);
+typedef SwiftInt (* _Nonnull AliasAnalysisEscaping2ValFn)(
+      void * _Nonnull, BridgedValue, BridgedValue);
+
+void AliasAnalysis_register(AliasAnalysisInitFn initFn,
+                            AliasAnalysisDestroyFn destroyFn,
+                            AliasAnalysisAddr2InstFn isAddrEscaping2InstFn,
+                            AliasAnalysisEscaping2InstFn isObjEscaping2InstFn,
+                            AliasAnalysisEscaping2ValFn isAddrVisibleFromObjFn,
+                            AliasAnalysisEscaping2ValFn mayPointToSameAddrFn);
+
 BridgedSlab PassContext_getNextSlab(BridgedSlab slab);
 BridgedSlab PassContext_getPreviousSlab(BridgedSlab slab);
 BridgedSlab PassContext_allocSlab(BridgedPassContext passContext,

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -282,24 +282,14 @@ bool swift::mayHaveSymmetricInterference(SILInstruction *User, SILValue Ptr, Ali
   if (!canUseObject(User))
     return false;
 
-  // Check whether releasing this value can call deinit and interfere with User.
-  if (AA->mayValueReleaseInterfereWithInstruction(User, Ptr))
-    return true;
-
-  // If the user is a load or a store and we can prove that it does not access
-  // the object then return true.
-  // Notice that we need to check all of the values of the object.
-  if (isa<StoreInst>(User)) {
-    if (AA->mayWriteToMemory(User, Ptr))
-      return true;
-    return false;
+  if (auto *LI = dyn_cast<LoadInst>(User)) {
+    return AA->isAddrVisibleFromObject(LI->getOperand(), Ptr);
   }
-
-  if (isa<LoadInst>(User) ) {
-    if (AA->mayReadFromMemory(User, Ptr))
-      return true;
-    return false;
+  if (auto *SI = dyn_cast<StoreInst>(User)) {
+    return AA->isAddrVisibleFromObject(SI->getDest(), Ptr);
   }
+  if (User->mayReadOrWriteMemory())
+    return true;
 
   // If we have a terminator instruction, see if it can use ptr. This currently
   // means that we first show that TI cannot indirectly use Ptr and then use