Merge pull request swiftlang#34252 from eeckstein/temp-rvalue-opt

SILOptimizer: fix a miscompile in TempRValueOpt and improve MemBehavior

Author: eeckstein

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -47,7 +47,6 @@ namespace {
   struct MemBehaviorKeyTy {
     // The SILValue pair:
     size_t V1, V2;
-    RetainObserveKind InspectionMode; 
   };
 }
 
@@ -201,24 +200,16 @@ class AliasAnalysis : public SILAnalysis {
 
   /// Use the alias analysis to determine the memory behavior of Inst with
   /// respect to V.
-  ///
-  /// TODO: When ref count behavior is separated from generic memory behavior,
-  /// the InspectionMode flag will be unnecessary.
-  MemoryBehavior computeMemoryBehavior(SILInstruction *Inst, SILValue V,
-                                       RetainObserveKind);
+  MemoryBehavior computeMemoryBehavior(SILInstruction *Inst, SILValue V);
 
   /// Use the alias analysis to determine the memory behavior of Inst with
   /// respect to V.
-  ///
-  /// TODO: When ref count behavior is separated from generic memory behavior,
-  /// the InspectionMode flag will be unnecessary.
-  MemoryBehavior computeMemoryBehaviorInner(SILInstruction *Inst, SILValue V,
-                                            RetainObserveKind);
+  MemoryBehavior computeMemoryBehaviorInner(SILInstruction *Inst, SILValue V);
 
   /// Returns true if \p Inst may read from memory in a manner that
   /// affects V.
   bool mayReadFromMemory(SILInstruction *Inst, SILValue V) {
-    auto B = computeMemoryBehavior(Inst, V, RetainObserveKind::IgnoreRetains);
+    auto B = computeMemoryBehavior(Inst, V);
     return B == MemoryBehavior::MayRead ||
            B == MemoryBehavior::MayReadWrite ||
            B == MemoryBehavior::MayHaveSideEffects;
@@ -227,7 +218,7 @@ class AliasAnalysis : public SILAnalysis {
   /// Returns true if \p Inst may write to memory in a manner that
   /// affects V.
   bool mayWriteToMemory(SILInstruction *Inst, SILValue V) {
-    auto B = computeMemoryBehavior(Inst, V, RetainObserveKind::IgnoreRetains);
+    auto B = computeMemoryBehavior(Inst, V);
     return B == MemoryBehavior::MayWrite ||
            B == MemoryBehavior::MayReadWrite ||
            B == MemoryBehavior::MayHaveSideEffects;
@@ -236,26 +227,10 @@ class AliasAnalysis : public SILAnalysis {
   /// Returns true if \p Inst may read or write to memory in a manner that
   /// affects V.
   bool mayReadOrWriteMemory(SILInstruction *Inst, SILValue V) {
-    auto B = computeMemoryBehavior(Inst, V, RetainObserveKind::IgnoreRetains);
+    auto B = computeMemoryBehavior(Inst, V);
     return MemoryBehavior::None != B;
   }
 
-  /// Returns true if Inst may have side effects in a manner that affects V.
-  bool mayHaveSideEffects(SILInstruction *Inst, SILValue V) {
-    auto B = computeMemoryBehavior(Inst, V, RetainObserveKind::ObserveRetains);
-    return B == MemoryBehavior::MayWrite ||
-           B == MemoryBehavior::MayReadWrite ||
-           B == MemoryBehavior::MayHaveSideEffects;
-  }
-
-  /// Returns true if Inst may have side effects in a manner that affects
-  /// V. This is independent of whether or not Inst may write to V and is meant
-  /// to encode notions such as ref count modifications.
-  bool mayHavePureSideEffects(SILInstruction *Inst, SILValue V) {
-    auto B = computeMemoryBehavior(Inst, V, RetainObserveKind::ObserveRetains);
-    return MemoryBehavior::MayHaveSideEffects == B;
-  }
-
   /// Returns true if \p Ptr may be released in the function call \p FAS.
   bool canApplyDecrementRefCount(FullApplySite FAS, SILValue Ptr);
 
@@ -268,8 +243,7 @@ class AliasAnalysis : public SILAnalysis {
   AliasKeyTy toAliasKey(SILValue V1, SILValue V2, SILType Type1, SILType Type2);
 
   /// Encodes the memory behavior query as a MemBehaviorKeyTy.
-  MemBehaviorKeyTy toMemoryBehaviorKey(SILInstruction *V1, SILValue V2,
-                                       RetainObserveKind K);
+  MemBehaviorKeyTy toMemoryBehaviorKey(SILInstruction *V1, SILValue V2);
 
   virtual void invalidate() override {
     AliasCache.clear();
@@ -330,24 +304,21 @@ namespace llvm {
   template <> struct DenseMapInfo<MemBehaviorKeyTy> {
     static inline MemBehaviorKeyTy getEmptyKey() {
       auto Allone = std::numeric_limits<size_t>::max();
-      return {0, Allone, RetainObserveKind::RetainObserveKindEnd};
+      return {0, Allone};
     }
     static inline MemBehaviorKeyTy getTombstoneKey() {
       auto Allone = std::numeric_limits<size_t>::max();
-      return {Allone, 0, RetainObserveKind::RetainObserveKindEnd};
+      return {Allone, 0};
     }
     static unsigned getHashValue(const MemBehaviorKeyTy V) {
       unsigned H = 0;
       H ^= DenseMapInfo<size_t>::getHashValue(V.V1);
       H ^= DenseMapInfo<size_t>::getHashValue(V.V2);
-      H ^= DenseMapInfo<int>::getHashValue(static_cast<int>(V.InspectionMode));
       return H;
     }
     static bool isEqual(const MemBehaviorKeyTy LHS,
                         const MemBehaviorKeyTy RHS) {
-      return LHS.V1 == RHS.V1 &&
-             LHS.V2 == RHS.V2 &&
-             LHS.InspectionMode == RHS.InspectionMode; 
+      return LHS.V1 == RHS.V1 && LHS.V2 == RHS.V2;
     }
   };
 }

include/swift/SILOptimizer/Analysis/SideEffectAnalysis.h

@@ -389,6 +389,13 @@ class FunctionSideEffects {
   /// instructions are considered as side effects.
   MemoryBehavior getMemBehavior(RetainObserveKind ScanKind) const;
 
+  /// Gets the memory behavior for an argument.
+  ///
+  /// This is derived from the combined argument and the global effects.
+  /// Also the argument type and convention are considered.
+  MemoryBehavior getArgumentBehavior(FullApplySite applySite,
+                                                unsigned argIdx);
+
   /// Get the global effects for the function. These are effects which cannot
   /// be associated to a specific parameter, e.g. writes to global variables
   /// or writes to unknown pointers.