Use the new side effects in LICM

Author: eeckstein

lib/SILOptimizer/LoopTransforms/LICM.cpp

@@ -24,9 +24,9 @@
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Analysis.h"
 #include "swift/SILOptimizer/Analysis/ArraySemantic.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
 #include "swift/SILOptimizer/Analysis/LoopAnalysis.h"
-#include "swift/SILOptimizer/Analysis/SideEffectAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
@@ -166,31 +166,56 @@ static bool isOnlyLoadedAndStored(AliasAnalysis *AA, InstSet &SideEffectInsts,
 /// Returns true if the \p SideEffectInsts set contains any memory writes which
 /// may alias with any memory which is read by \p AI.
 /// Note: This function should only be called on a read-only apply!
-static bool mayWriteTo(AliasAnalysis *AA, SideEffectAnalysis *SEA,
+static bool mayWriteTo(AliasAnalysis *AA, BasicCalleeAnalysis *BCA,
                        InstSet &SideEffectInsts, ApplyInst *AI) {
-  FunctionSideEffects E;
-  SEA->getCalleeEffects(E, AI);
-  assert(E.getMemBehavior(RetainObserveKind::IgnoreRetains) <=
-         SILInstruction::MemoryBehavior::MayRead &&
-         "apply should only read from memory");
-  assert(!E.getGlobalEffects().mayRead() &&
-         "apply should not have global effects");
-
-  for (unsigned Idx = 0, End = AI->getNumArguments(); Idx < End; ++Idx) {
-    auto &ArgEffect = E.getParameterEffects()[Idx];
-    assert(!ArgEffect.mayRelease() && "apply should only read from memory");
-    if (!ArgEffect.mayRead())
-      continue;
 
-    SILValue Arg = AI->getArgument(Idx);
+  if (BCA->getMemoryBehavior(FullApplySite::isa(AI), /*observeRetains*/true) ==
+      SILInstruction::MemoryBehavior::None) {
+    return false;
+  }
 
-    // Check if the memory addressed by the argument may alias any writes.
-    for (auto *I : SideEffectInsts) {
-      if (AA->mayWriteToMemory(I, Arg)) {
-        LLVM_DEBUG(llvm::dbgs() << "  mayWriteTo\n" << *I << " to "
-                                << *AI << "\n");
-        return true;
+  // Check if the memory addressed by the argument may alias any writes.
+  for (auto *inst : SideEffectInsts) {
+    switch (inst->getKind()) {
+      case SILInstructionKind::StoreInst: {
+        auto *si = cast<StoreInst>(inst);
+        if (si->getOwnershipQualifier() == StoreOwnershipQualifier::Assign)
+          return true;
+        if (AA->mayReadFromMemory(AI, si->getDest()))
+          return true;
+        break;
+      }
+      case SILInstructionKind::CopyAddrInst: {
+        auto *ca = cast<CopyAddrInst>(inst);
+        if (!ca->isInitializationOfDest())
+          return true;
+        if (AA->mayReadFromMemory(AI, ca->getDest()))
+          return true;
+        break;
       }
+      case SILInstructionKind::ApplyInst:
+      case SILInstructionKind::BeginApplyInst:
+      case SILInstructionKind::TryApplyInst: {
+        if (BCA->getMemoryBehavior(FullApplySite::isa(inst), /*observeRetains*/false) >
+            SILInstruction::MemoryBehavior::MayRead)
+          return true;
+        break;
+      }
+      case SILInstructionKind::CondFailInst:
+      case SILInstructionKind::StrongRetainInst:
+      case SILInstructionKind::UnmanagedRetainValueInst:
+      case SILInstructionKind::RetainValueInst:
+      case SILInstructionKind::StrongRetainUnownedInst:
+      case SILInstructionKind::FixLifetimeInst:
+      case SILInstructionKind::KeyPathInst:
+      case SILInstructionKind::DeallocStackInst:
+      case SILInstructionKind::DeallocStackRefInst:
+      case SILInstructionKind::DeallocRefInst:
+        break;
+      default:
+        if (inst->mayWriteToMemory())
+          return true;
+        break;
     }
   }
   return false;
@@ -509,7 +534,7 @@ class LoopTreeOptimization {
   InstSet toDelete;
   SILLoopInfo *LoopInfo;
   AliasAnalysis *AA;
-  SideEffectAnalysis *SEA;
+  BasicCalleeAnalysis *BCA;
   DominanceInfo *DomTree;
   PostDominanceAnalysis *PDA;
   PostDominanceInfo *postDomTree = nullptr;
@@ -540,11 +565,11 @@ class LoopTreeOptimization {
 
 public:
   LoopTreeOptimization(SILLoop *TopLevelLoop, SILLoopInfo *LI,
-                       AliasAnalysis *AA, SideEffectAnalysis *SEA,
+                       AliasAnalysis *AA, BasicCalleeAnalysis *BCA,
                        DominanceInfo *DT, PostDominanceAnalysis *PDA,
                        AccessStorageAnalysis *ASA,
                        bool RunsOnHighLevelSil)
-      : LoopInfo(LI), AA(AA), SEA(SEA), DomTree(DT), PDA(PDA), ASA(ASA),
+      : LoopInfo(LI), AA(AA), BCA(BCA), DomTree(DT), PDA(PDA), ASA(ASA),
         Changed(false), RunsOnHighLevelSIL(RunsOnHighLevelSil) {
     // Collect loops for a recursive bottom-up traversal in the loop tree.
     BotUpWorkList.push_back(TopLevelLoop);
@@ -562,6 +587,8 @@ class LoopTreeOptimization {
   /// Propagate the sub-loops' summaries up to the current loop.
   void propagateSummaries(std::unique_ptr<LoopNestSummary> &CurrSummary);
 
+  bool isSafeReadOnlyApply(BasicCalleeAnalysis *BCA, ApplyInst *AI);
+
   /// Collect a set of instructions that can be hoisted
   void analyzeCurrentLoop(std::unique_ptr<LoopNestSummary> &CurrSummary);
 
@@ -658,19 +685,22 @@ void LoopTreeOptimization::propagateSummaries(
   }
 }
 
-static bool isSafeReadOnlyApply(SideEffectAnalysis *SEA, ApplyInst *AI) {
-  FunctionSideEffects E;
-  SEA->getCalleeEffects(E, AI);
+bool LoopTreeOptimization::isSafeReadOnlyApply(BasicCalleeAnalysis *BCA, ApplyInst *AI) {
+  if (auto ri = AI->getSingleResult()) {
+    // We don't balance CSE'd apply results which return an owned value.
+    if (ri.getValue().getConvention() != ResultConvention::Unowned)
+      return false;
+  }
 
-  if (E.getGlobalEffects().mayRead()) {
-    // If we have Global effects,
-    // we don't know which memory is read in the callee.
-    // Therefore we bail for safety
-    return false;
+  if (RunsOnHighLevelSIL) {
+    // The array-property-opt needs this semantic call inside the loop.
+    // After high-level SIL we can hoist it (if it's not inlined already).
+    if (ArraySemanticsCall(AI, "array.props.isNativeTypeChecked"))
+      return false;
   }
 
-  auto MB = E.getMemBehavior(RetainObserveKind::ObserveRetains);
-  return (MB <= SILInstruction::MemoryBehavior::MayRead);
+  return BCA->getMemoryBehavior(AI, /*observeRetains*/false) <=
+         SILInstruction::MemoryBehavior::MayRead;
 }
 
 static void checkSideEffects(swift::SILInstruction &Inst,
@@ -695,26 +725,31 @@ static bool canHoistUpDefault(SILInstruction *inst, SILLoop *Loop,
     return false;
   }
 
-  if (inst->getMemoryBehavior() == SILInstruction::MemoryBehavior::None) {
-    return true;
-  }
-
-  if (!RunsOnHighLevelSil) {
-    return false;
-  }
-
   // We can’t hoist everything that is hoist-able
   // The canHoist method does not do all the required analysis
   // Some of the work is done at COW Array Opt
   // TODO: Refactor COW Array Opt + canHoist - radar 41601468
   ArraySemanticsCall semCall(inst);
   switch (semCall.getKind()) {
-  case ArrayCallKind::kGetCount:
-  case ArrayCallKind::kGetCapacity:
-    return semCall.canHoist(Preheader->getTerminator(), DT);
-  default:
-    return false;
+    case ArrayCallKind::kGetCount:
+    case ArrayCallKind::kGetCapacity:
+      if (RunsOnHighLevelSil && semCall.canHoist(Preheader->getTerminator(), DT))
+        return true;
+      break;
+    case ArrayCallKind::kArrayPropsIsNativeTypeChecked:
+      // The array-property-opt needs this semantic call inside the loop.
+      // After high-level SIL we can hoist it (if it's not inlined already).
+      if (RunsOnHighLevelSil)
+        return false;
+      break;
+    default:
+      break;
+  }
+
+  if (inst->getMemoryBehavior() == SILInstruction::MemoryBehavior::None) {
+    return true;
   }
+  return false;
 }
 
 // Check If all the end accesses of the given begin do not prevent hoisting
@@ -874,7 +909,7 @@ void LoopTreeOptimization::analyzeCurrentLoop(
         break;
       case SILInstructionKind::ApplyInst: {
         auto *AI = cast<ApplyInst>(&Inst);
-        if (isSafeReadOnlyApply(SEA, AI)) {
+        if (isSafeReadOnlyApply(BCA, AI)) {
           ReadOnlyApplies.push_back(AI);
         } else if (SILFunction *callee = AI->getReferencedFunctionOrNull()) {
           // Calls to global inits are different because we don't care about
@@ -903,7 +938,7 @@ void LoopTreeOptimization::analyzeCurrentLoop(
   }
 
   for (auto *AI : ReadOnlyApplies) {
-    if (!mayWriteTo(AA, SEA, sideEffects, AI)) {
+    if (!mayWriteTo(AA, BCA, sideEffects, AI)) {
       HoistUp.insert(AI);
     }
   }
@@ -1471,7 +1506,7 @@ class LICM : public SILFunctionTransform {
     DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>();
     PostDominanceAnalysis *PDA = PM->getAnalysis<PostDominanceAnalysis>();
     AliasAnalysis *AA = PM->getAnalysis<AliasAnalysis>(F);
-    SideEffectAnalysis *SEA = PM->getAnalysis<SideEffectAnalysis>();
+    BasicCalleeAnalysis *BCA = PM->getAnalysis<BasicCalleeAnalysis>();
     AccessStorageAnalysis *ASA = getAnalysis<AccessStorageAnalysis>();
     DominanceInfo *DomTree = nullptr;
 
@@ -1480,7 +1515,7 @@ class LICM : public SILFunctionTransform {
 
     for (auto *TopLevelLoop : *LoopInfo) {
       if (!DomTree) DomTree = DA->get(F);
-      LoopTreeOptimization Opt(TopLevelLoop, LoopInfo, AA, SEA, DomTree, PDA,
+      LoopTreeOptimization Opt(TopLevelLoop, LoopInfo, AA, BCA, DomTree, PDA,
                                ASA, RunsOnHighLevelSil);
       Changed |= Opt.optimize();
     }

test/SILOptimizer/licm.sil

@@ -1,5 +1,7 @@
 // RUN: %target-sil-opt -enforce-exclusivity=none -enable-sil-verify-all %s -licm | %FileCheck %s
 
+// REQUIRES: swift_in_compiler
+
 // Declare this SIL to be canonical because some tests break raw SIL
 // conventions. e.g. address-type block args. -enforce-exclusivity=none is also
 // required to allow address-type block args in canonical SIL.

test/SILOptimizer/licm_apply.sil

@@ -1,4 +1,6 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -licm | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -compute-side-effects -licm | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
 
 sil_stage canonical