Merge pull request #61715 from eeckstein/alias-analysis

Use new escape- and side-effect analysis in alias analysis and other optimizations

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -60,4 +60,148 @@ struct AliasAnalysis {
     // Any other non-address value means: all addresses of any referenced class instances within the value.
     return SmallProjectionPath(.anyValueFields).push(.anyClassField).push(.anyValueFields)
   }
+  
+  static func register() {
+    AliasAnalysis_register(
+      // getMemEffectsFn
+      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> BridgedMemoryBehavior in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let inst = bridgedInst.instruction
+        let val = bridgedVal.value
+        let path = AliasAnalysis.getPtrOrAddressPath(for: val)
+        if let apply = inst as? ApplySite {
+          let effect = getMemoryEffect(of: apply, for: val, path: path, context)
+          switch (effect.read, effect.write) {
+            case (false, false): return NoneBehavior
+            case (true, false):  return MayReadBehavior
+            case (false, true):  return MayWriteBehavior
+            case (true, true):   return MayReadWriteBehavior
+          }
+        }
+        if val.at(path).isAddressEscaping(using: EscapesToInstructionVisitor(target: inst), context) {
+          return MayReadWriteBehavior
+        }
+        return NoneBehavior
+      },
+
+      // isObjReleasedFn
+      { (bridgedCtxt: BridgedPassContext, bridgedObj: BridgedValue, bridgedInst: BridgedInstruction) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let inst = bridgedInst.instruction
+        let obj = bridgedObj.value
+        let path = SmallProjectionPath(.anyValueFields)
+        if let apply = inst as? ApplySite {
+          let effect = getOwnershipEffect(of: apply, for: obj, path: path, context)
+          return effect.destroy
+        }
+        return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst), context)
+      },
+
+      // isAddrVisibleFromObj
+      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
+
+        // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
+        // considered which are transitively visible from `bridgedObj`.
+        let anythingReachableFromObj = bridgedObj.value.at(SmallProjectionPath(.anything))
+        return addr.canAddressAlias(with: anythingReachableFromObj, context)
+      },
+
+      // canReferenceSameFieldFn
+      { (bridgedCtxt: BridgedPassContext, bridgedLhs: BridgedValue, bridgedRhs: BridgedValue) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+
+        // If `lhs` or `rhs` is not an address, but an object, it means: check for alias of any class
+        // field address of the object.
+        let lhs = bridgedLhs.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedLhs.value))
+        let rhs = bridgedRhs.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedRhs.value))
+        return lhs.canAddressAlias(with: rhs, context)
+      }
+    )
+  }
+}
+
+private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Memory {
+  let calleeAnalysis = context.calleeAnalysis
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis)
+  let memoryEffects: SideEffects.Memory
+
+  // First try to figure out to which argument(s) the address "escapes" to.
+  if let result = address.at(path).visitAddress(using: visitor, context) {
+    // The resulting effects are the argument effects to which `address` escapes to.
+    memoryEffects = result.memory
+  } else {
+    // `address` has unknown escapes. So we have to take the global effects of the called function(s).
+    memoryEffects = calleeAnalysis.getSideEffects(of: apply).memory
+  }
+  // Do some magic for `let` variables. Function calls cannot modify let variables.
+  // The only exception is that the let variable is directly passed to an indirect out of the
+  // apply.
+  // TODO: make this a more formal and verified approach.
+  if memoryEffects.write && address.accessBase.isLet && !address.isIndirectResult(of: apply) {
+    return SideEffects.Memory(read: memoryEffects.read, write: false)
+  }
+  return memoryEffects
+}
+
+private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Ownership {
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis)
+  if let result = value.at(path).visit(using: visitor, context) {
+    // The resulting effects are the argument effects to which `value` escapes to.
+    return result.ownership
+  } else {
+    // `value` has unknown escapes. So we have to take the global effects of the called function(s).
+    return visitor.calleeAnalysis.getSideEffects(of: apply).ownership
+  }
+}
+
+private struct SideEffectsVisitor : EscapeVisitorWithResult {
+  let apply: ApplySite
+  let calleeAnalysis: CalleeAnalysis
+  var result = SideEffects.GlobalEffects()
+
+  mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+    let user = operand.instruction
+    if user is ReturnInst {
+      // Anything which is returned cannot escape to an instruction inside the function.
+      return .ignore
+    }
+    if user == apply {
+      if let argIdx = apply.argumentIndex(of: operand) {
+        let e = calleeAnalysis.getSideEffects(of: apply, forArgument: argIdx, path: path.projectionPath)
+        result.merge(with: e)
+      }
+    }
+    return .continueWalk
+  }
+}
+
+private extension Value {
+  /// Returns true if this address is passed as indirect out of `apply`.
+  func isIndirectResult(of apply: ApplySite) -> Bool {
+    guard let fullApply = apply as? FullApplySite else {
+      return false
+    }
+    if fullApply.numIndirectResultArguments == 0 {
+      return false
+    }
+
+    var walker = IsIndirectResultWalker(apply: fullApply)
+    return walker.walkDownUses(ofAddress: self, path: UnusedWalkingPath()) == .abortWalk
+  }
+}
+
+private struct IsIndirectResultWalker: AddressDefUseWalker {
+  let apply: FullApplySite
+
+  mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
+    if address.instruction == apply,
+       let argIdx = apply.argumentIndex(of: address),
+       argIdx < apply.numIndirectResultArguments {
+      return .abortWalk
+    }
+    return .continueWalk
+  }
 }
+

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -79,5 +79,6 @@ private func registerSwiftPasses() {
 }
 
 private func registerSwiftAnalyses() {
+  AliasAnalysis.register()
   CalleeAnalysis.register()
 }

include/swift/SILOptimizer/Analysis/AccessStorageAnalysis.h

@@ -19,22 +19,19 @@
 // FunctionAccessStorage.unidentifiedAccess. This does not imply that all
 // accesses within the function have Unidentified AccessStorage.
 //
-// Note: This interprocedural analysis can be easily augmented to simultaneously
-// compute FunctionSideEffects, without using a separate analysis, by adding
-// FunctionSideEffects as a member of FunctionAccessStorage. However, passes
-// that use AccessStorageAnalysis do not currently need SideEffectAnalysis.
-//
 //===----------------------------------------------------------------------===//
 #ifndef SWIFT_SILOPTIMIZER_ANALYSIS_ACCESSED_STORAGE_ANALYSIS_H
 #define SWIFT_SILOPTIMIZER_ANALYSIS_ACCESSED_STORAGE_ANALYSIS_H
 
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
-#include "swift/SILOptimizer/Analysis/SideEffectAnalysis.h"
+#include "swift/SILOptimizer/Analysis/BottomUpIPAnalysis.h"
 
 namespace swift {
 
+class BasicCalleeAnalysis;
+
 /// Information about a formal access within a function pertaining to a
 /// particular AccessStorage location.
 class StorageAccessInfo : public AccessStorage {
@@ -340,16 +337,121 @@ class FunctionAccessStorage {
 /// Use the GenericFunctionEffectAnalysis API to get the results of the analysis:
 /// - geEffects(SILFunction*)
 /// - getCallSiteEffects(FunctionEffects &callEffects, FullApplySite fullApply)
-class AccessStorageAnalysis
-    : public GenericFunctionEffectAnalysis<FunctionAccessStorage> {
+class AccessStorageAnalysis : public BottomUpIPAnalysis {
+
+  /// Stores the analysis data, e.g. side-effects, for a function.
+  struct FunctionInfo : public FunctionInfoBase<FunctionInfo> {
+
+    /// The function effects.
+    FunctionAccessStorage functionEffects;
+
+    /// Back-link to the function.
+    SILFunction *F;
+
+    /// Used during recomputation to indicate if the side-effects of a caller
+    /// must be updated.
+    bool needUpdateCallers = false;
+
+    FunctionInfo(SILFunction *F) : F(F) {}
+
+    /// Clears the analysis data on invalidation.
+    void clear() { functionEffects.clear(); }
+  };
+
+  typedef BottomUpFunctionOrder<FunctionInfo> FunctionOrder;
+
+  enum {
+    /// The maximum call-graph recursion depth for recomputing the analysis.
+    /// This is a relatively small number to reduce compile time in case of
+    /// large cycles in the call-graph.
+    /// In case of no cycles, we should not hit this limit at all because the
+    /// pass manager processes functions in bottom-up order.
+    MaxRecursionDepth = 5
+  };
+
+  /// All the function effect information for the whole module.
+  llvm::DenseMap<SILFunction *, FunctionInfo *> functionInfoMap;
+
+  /// The allocator for the map of values in FunctionInfoMap.
+  llvm::SpecificBumpPtrAllocator<FunctionInfo> allocator;
+
+  /// Callee analysis, used for determining the callees at call sites.
+  BasicCalleeAnalysis *BCA;
+
 public:
   AccessStorageAnalysis()
-      : GenericFunctionEffectAnalysis<FunctionAccessStorage>(
-            SILAnalysisKind::AccessStorage) {}
+      : BottomUpIPAnalysis(SILAnalysisKind::AccessStorage) {}
 
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == SILAnalysisKind::AccessStorage;
   }
+
+  const FunctionAccessStorage &getEffects(SILFunction *F) {
+    FunctionInfo *functionInfo = getFunctionInfo(F);
+    if (!functionInfo->isValid())
+      recompute(functionInfo);
+    return functionInfo->functionEffects;
+  }
+
+  /// Get the merged effects of all callees at the given call site from the
+  /// callee's perspective (don't transform parameter effects).
+  void getCalleeEffects(FunctionAccessStorage &calleeEffects,
+                        FullApplySite fullApply);
+
+  /// Get the merge effects of all callees at the given call site from the
+  /// caller's perspective. Parameter effects are translated into information
+  /// for the caller's arguments, and local effects are dropped.
+  void getCallSiteEffects(FunctionAccessStorage &callEffects,
+                          FullApplySite fullApply) {
+    FunctionAccessStorage calleeEffects;
+    getCalleeEffects(calleeEffects, fullApply);
+    callEffects.mergeFromApply(calleeEffects, fullApply);
+  }
+
+  BasicCalleeAnalysis *getBasicCalleeAnalysis() { return BCA; }
+
+  virtual void initialize(SILPassManager *PM) override;
+
+  /// Invalidate all information in this analysis.
+  virtual void invalidate() override;
+
+  /// Invalidate all of the information for a specific function.
+  virtual void invalidate(SILFunction *F, InvalidationKind K) override;
+
+  /// Notify the analysis about a newly created function.
+  virtual void notifyAddedOrModifiedFunction(SILFunction *F) override {}
+
+  /// Notify the analysis about a function which will be deleted from the
+  /// module.
+  virtual void notifyWillDeleteFunction(SILFunction *F) override {
+    invalidate(F, InvalidationKind::Nothing);
+  }
+
+  /// Notify the analysis about changed witness or vtables.
+  virtual void invalidateFunctionTables() override {}
+
+private:
+  /// Gets or creates FunctionAccessStorage for \p F.
+  FunctionInfo *getFunctionInfo(SILFunction *F) {
+    FunctionInfo *&functionInfo = functionInfoMap[F];
+    if (!functionInfo) {
+      functionInfo = new (allocator.Allocate()) FunctionInfo(F);
+    }
+    return functionInfo;
+  }
+
+  /// Analyze the side-effects of a function, including called functions.
+  /// Visited callees are added to \p BottomUpOrder until \p RecursionDepth
+  /// reaches MaxRecursionDepth.
+  void analyzeFunction(FunctionInfo *functionInfo, FunctionOrder &bottomUpOrder,
+                       int recursionDepth);
+
+  void analyzeCall(FunctionInfo *functionInfo, FullApplySite fullApply,
+                   FunctionOrder &bottomUpOrder, int recursionDepth);
+
+  /// Recomputes the side-effect information for the function \p Initial and
+  /// all called functions, up to a recursion depth of MaxRecursionDepth.
+  void recompute(FunctionInfo *initialInfo);
 };
 
 } // end namespace swift

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -20,9 +20,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.
 class AliasAnalysis {
@@ -74,8 +71,7 @@ class AliasAnalysis {
 
   using TBAACacheKey = std::pair<SILType, SILType>;
 
-  SideEffectAnalysis *SEA;
-  EscapeAnalysis *EA;
+  SILPassManager *PM;
 
   /// A cache for the computation of TBAA. True means that the types may
   /// alias. False means that the types must not alias.
@@ -125,8 +121,7 @@ class AliasAnalysis {
   bool isInImmutableScope(SILInstruction *inst, SILValue V);
 
 public:
-  AliasAnalysis(SideEffectAnalysis *SEA, EscapeAnalysis *EA)
-    : SEA(SEA), EA(EA) {}
+  AliasAnalysis(SILPassManager *PM) : PM(PM) {}
 
   static SILAnalysisKind getAnalysisKind() { return SILAnalysisKind::Alias; }
 
@@ -158,11 +153,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 +196,19 @@ 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 getMemoryBehaviorOfInst(SILValue addr, SILInstruction *toInst);
+
+  /// Returns true if the object(s of) `obj` can escape to `toInst`.
+  bool isObjectReleasedByInst(SILValue obj, SILInstruction *toInst);
+
+  /// 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/Analysis.def

@@ -34,7 +34,6 @@ SIL_ANALYSIS(Destructor)
 SIL_ANALYSIS(DifferentiableActivity)
 SIL_ANALYSIS(Dominance)
 SIL_ANALYSIS(EpilogueARC)
-SIL_ANALYSIS(Escape)
 SIL_ANALYSIS(InductionVariable)
 SIL_ANALYSIS(Loop)
 SIL_ANALYSIS(LoopRegion)
@@ -44,7 +43,6 @@ SIL_ANALYSIS(PostDominance)
 SIL_ANALYSIS(PostOrder)
 SIL_ANALYSIS(ProtocolConformance)
 SIL_ANALYSIS(RCIdentity)
-SIL_ANALYSIS(SideEffect)
 SIL_ANALYSIS(TypeExpansion)
 SIL_ANALYSIS(PassManagerVerifier)
 SIL_ANALYSIS(DeadEndBlocks)