AliasAnalysis: check for immutable scopes.

 If the "regular" alias analysis thinks that an instruction may write to an address, check if the instruction is in an immutable scope of V.
That means that even if we don't know anything about the instruction (e.g. a call to an unknown function), we can be sure that it cannot write to the address.

An immutable scope is for example a read-only begin_access/end_access scope.
Another example is a borrow scope of an immutable copy-on-write buffer, for example:
   %b = begin_borrow %array_buffer
   %addr = ref_element_addr [immutable] %b : $BufferType, #BufferType.someField

Author: eeckstein

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -113,6 +113,19 @@ class AliasAnalysis : public SILAnalysis {
   /// The computeMemoryBehavior() method uses this map to cache queries.
   llvm::DenseMap<MemBehaviorKeyTy, MemoryBehavior> MemoryBehaviorCache;
 
+  /// Set of instructions inside immutable-scopes.
+  ///
+  /// Contains pairs of intruction indices: the first instruction is the begin-
+  /// scope instruction (e.g. begin_access), the second instruction is an
+  /// instruction inside the scope (only may-write instructions are considered).
+  llvm::DenseSet<MemBehaviorKeyTy> instsInImmutableScopes;
+
+  /// Computed immutable scopes.
+  ///
+  /// Contains the begin-scope instruction's indices (e.g. begin_access) of
+  /// all computed scopes.
+  llvm::DenseSet<ValueIndexTy> immutableScopeComputed;
+
   /// The caches can't directly map a pair of value/instruction pointers
   /// to results because we'd like to be able to remove deleted instruction
   /// pointers without having to scan the whole map. So, instead of storing
@@ -135,6 +148,10 @@ class AliasAnalysis : public SILAnalysis {
 
   virtual bool needsNotifications() override { return true; }
 
+  void computeImmutableScope(SingleValueInstruction *beginScopeInst,
+                             ValueIndexTy beginIdx);
+
+  bool isInImmutableScope(SILInstruction *inst, SILValue V);
 
 public:
   AliasAnalysis(SILModule *M)
@@ -246,6 +263,8 @@ class AliasAnalysis : public SILAnalysis {
     MemoryBehaviorCache.clear();
     InstructionToIndex.clear();
     ValueToIndex.clear();
+    instsInImmutableScopes.clear();
+    immutableScopeComputed.clear();
   }
 
   virtual void invalidate(SILFunction *,

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -15,6 +15,8 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/SILVisitor.h"
+#include "swift/SIL/OwnershipUtils.h"
+#include "swift/SIL/BasicBlockBits.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/EscapeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SideEffectAnalysis.h"
@@ -28,6 +30,11 @@ using namespace swift;
 // memory usage of this cache.
 static const int MemoryBehaviorAnalysisMaxCacheSize = 16384;
 
+// The maximum size of instsInImmutableScopes.
+// Usually more than enough. But in corner cases it can grow quadratically (in
+// case of many large nested immutable scopes).
+static const int ImmutableScopeInstsMaxSize = 18384;
+
 //===----------------------------------------------------------------------===//
 //                       Memory Behavior Implementation
 //===----------------------------------------------------------------------===//
@@ -536,12 +543,162 @@ AliasAnalysis::computeMemoryBehavior(SILInstruction *Inst, SILValue V) {
   return Result;
 }
 
+/// If \p V is an address of an immutable memory, return the begin of the
+/// scope where the memory can be considered to be immutable.
+///
+/// This is either a ``begin_access [read]`` in case V is the result of the
+/// begin_access or a projection of it.
+/// Or it is the begin of a borrow scope (begin_borrow, load_borrow, a
+/// guaranteed function argument) of an immutable copy-on-write buffer.
+/// For example:
+///   %b = begin_borrow %array_buffer
+///   %V = ref_element_addr [immutable] %b : $BufferType, #BufferType.someField
+///
+static SILValue getBeginScopeInst(SILValue V) {
+  SILValue accessScope = getAccessScope(V);
+  if (auto *access = dyn_cast<BeginAccessInst>(accessScope)) {
+    if (access->getAccessKind() == SILAccessKind::Read &&
+        access->getEnforcement() != SILAccessEnforcement::Unsafe)
+      return access;
+    return SILValue();
+  }
+  SILValue accessBase = getAccessBase(V);
+  SILValue object;
+  if (auto *elementAddr = dyn_cast<RefElementAddrInst>(accessBase)) {
+    if (!elementAddr->isImmutable())
+      return SILValue();
+    object = elementAddr->getOperand();
+  } else if (auto *tailAddr = dyn_cast<RefTailAddrInst>(accessBase)) {
+    if (!tailAddr->isImmutable())
+      return SILValue();
+    object = tailAddr->getOperand();
+  } else {
+    return SILValue();
+  }
+  if (BorrowedValue borrowedObj = getSingleBorrowIntroducingValue(object)) {
+    return borrowedObj.value;
+  }
+  return SILValue();
+}
+
+/// Collect all instructions which are inside an immutable scope.
+///
+/// The \p beginScopeInst is either a ``begin_access [read]`` or the begin of a
+/// borrow scope (begin_borrow, load_borrow) of an immutable copy-on-write
+/// buffer.
+void AliasAnalysis::computeImmutableScope(SingleValueInstruction *beginScopeInst,
+                                          ValueIndexTy beginIdx) {
+  BasicBlockSet visitedBlocks(beginScopeInst->getFunction());
+  llvm::SmallVector<std::pair<SILInstruction *, SILBasicBlock *>, 16> workList;
+  
+  auto addEndScopeInst = [&](SILInstruction *endScope) {
+    workList.push_back({endScope, endScope->getParent()});
+    bool isNew = visitedBlocks.insert(endScope->getParent());
+    (void)isNew;
+    assert(isNew);
+  };
+  
+  // First step: add all scope-ending instructions to the worklist.
+  if (auto *beginAccess = dyn_cast<BeginAccessInst>(beginScopeInst)) {
+    for (EndAccessInst *endAccess : beginAccess->getEndAccesses()) {
+      addEndScopeInst(endAccess);
+    }
+  } else {
+    visitTransitiveEndBorrows(BorrowedValue(beginScopeInst), addEndScopeInst);
+  }
+
+  // Second step: walk up the control flow until the beginScopeInst and add
+  // all (potentially) memory writing instructions to instsInImmutableScopes.
+  while (!workList.empty()) {
+    auto instAndBlock = workList.pop_back_val();
+    SILBasicBlock *block = instAndBlock.second;
+    // If the worklist entry doesn't have an instruction, start at the end of
+    // the block.
+    auto iter = instAndBlock.first ? instAndBlock.first->getIterator()
+                                   : block->end();
+    // Walk up the instruction list - either to the begin of the block or until
+    // we hit the beginScopeInst.
+    while (true) {
+      if (iter == block->begin()) {
+        assert(block != block->getParent()->getEntryBlock() &&
+               "didn't find the beginScopeInst when walking up the CFG");
+        // Add all predecessor blocks to the worklist.
+        for (SILBasicBlock *pred : block->getPredecessorBlocks()) {
+          if (visitedBlocks.insert(pred))
+            workList.push_back({nullptr, pred});
+        }
+        break;
+      }
+      --iter;
+      SILInstruction *inst = &*iter;
+      if (inst == beginScopeInst) {
+        // When we are at the beginScopeInst we terminate the CFG walk.
+        break;
+      }
+      if (inst->mayWriteToMemory()) {
+        instsInImmutableScopes.insert({beginIdx,
+                                       InstructionToIndex.getIndex(inst)});
+      }
+    }
+  }
+}
+
+/// Returns true if \p inst is in an immutable scope of V.
+///
+/// That means that even if we don't know anything about inst, we can be sure
+/// that inst cannot write to V.
+/// An immutable scope is for example a read-only begin_access/end_access scope.
+/// Another example is a borrow scope of an immutable copy-on-write buffer.
+bool AliasAnalysis::isInImmutableScope(SILInstruction *inst, SILValue V) {
+  if (!V->getType().isAddress())
+    return false;
+    
+  SILValue beginScope = getBeginScopeInst(V);
+  if (!beginScope)
+    return false;
+
+  if (auto *funcArg = dyn_cast<SILFunctionArgument>(beginScope)) {
+    // The immutable scope (= an guaranteed argument) spans over the whole
+    // function. We don't need to do any scope computation in this case.
+    assert(funcArg->getArgumentConvention().isGuaranteedConvention());
+    return true;
+  }
+
+  auto *beginScopeInst = dyn_cast<SingleValueInstruction>(beginScope);
+  if (!beginScopeInst)
+    return false;
+
+  ValueIndexTy beginIdx = InstructionToIndex.getIndex(beginScopeInst);
+  
+  // Recompute the scope if not done yet.
+  if (immutableScopeComputed.insert(beginIdx).second) {
+    // In practice this will never happen. Just be be sure to not run into
+    // quadratic complexity in obscure corner cases.
+    if (instsInImmutableScopes.size() > ImmutableScopeInstsMaxSize)
+      return false;
+
+    computeImmutableScope(beginScopeInst, beginIdx);
+  }
+
+  ValueIndexTy instIdx = InstructionToIndex.getIndex(inst);
+  return instsInImmutableScopes.contains({beginIdx, instIdx});
+}
+
 MemBehavior
 AliasAnalysis::computeMemoryBehaviorInner(SILInstruction *Inst, SILValue V) {
   LLVM_DEBUG(llvm::dbgs() << "GET MEMORY BEHAVIOR FOR:\n    " << *Inst << "    "
                           << *V);
   assert(SEA && "SideEffectsAnalysis must be initialized!");
-  return MemoryBehaviorVisitor(this, SEA, EA, V).visit(Inst);
+  
+  MemBehavior result = MemoryBehaviorVisitor(this, SEA, EA, V).visit(Inst);
+  
+  // If the "regular" alias analysis thinks that Inst may modify V, check if
+  // Inst is in an immutable scope of V.
+  if (result > MemBehavior::MayRead && isInImmutableScope(Inst, V)) {
+    return (result == MemBehavior::MayWrite) ? MemBehavior::None
+                                             : MemBehavior::MayRead;
+  }
+  return result;
 }
 
 MemBehaviorKeyTy AliasAnalysis::toMemoryBehaviorKey(SILInstruction *V1,

test/SILOptimizer/licm_exclusivity.sil

@@ -29,10 +29,10 @@ sil hidden_external @globalAddressor : $@convention(thin) () -> Builtin.RawPoint
 // CHECK-LABEL: sil @hoist_access_with_conflict : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
+// CHECK-NEXT: load
 // CHECK-NEXT: br bb1
 // CHECK: apply
-// CHECK: load
-// CHECK: cond_br
+// CHECK-NEXT: cond_br
 // CHECK: bb2
 // CHECK: end_access [[BEGIN]]
 // CHECK-LABEL: } // end sil function 'hoist_access_with_conflict'
@@ -89,9 +89,9 @@ bb2:
 // CHECK-LABEL: sil @hoist_access_with_may_release : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
+// CHECK-NEXT: load
 // CHECK-NEXT: br bb1
 // CHECK: apply
-// CHECK: load
 // CHECK: cond_br
 // CHECK: bb2
 // CHECK: end_access [[BEGIN]]
@@ -153,10 +153,10 @@ bb2:
 // CHECK-LABEL: sil @hoist_access_static : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [read] [static] [[GLOBAL]] : $*X
+// CHECK-NEXT: load
 // CHECK-NEXT: br bb1
 // CHECK: apply
-// CHECK: load
-// CHECK: cond_br
+// CHECK-NEXT: cond_br
 // CHECK: bb2
 // CHECK: end_access [[BEGIN]]
 // CHECK-LABEL: } // end sil function 'hoist_access_static'