[NFC] SIL: Clarified deinit barrier APIs.

An instruction is a deinit barrier whenever one of three component
predicates is true for it.  In the case of applies, it is true whenever
one of those three predicates is true for any of the instructions in any
of its callees; that fact is cached in the side-effect analysis of every
function.

If side-effect analysis or callee analysis is unavailable, in order to
define each of those three component predicates on a
`FullApplySite`/`EndApplyInst`/`AbortApplyInst`, it would be necessary
to define them to conservatively return true: it isn't known whether any
of the instructions in any of the callees were deinit barriers.

Refactored the two versions of the deinit barrier predicate (namely
`Instruction.isDeinitBarrier(_:) and
`swift::mayBeDeinitBarrierNotConsideringSideEffects`) to handle
`FullApplySite`/`EndApplyInst`/`AbortApplyInst`s specially first (to
look up the callees' side-effect and to conservatively bail,
respectively).  Asserted that the three component predicates are not
called with `FullApplySite`/`EndApplyInst`/`AbortApplyInst`s.  Callers
should instead use the `isDeinitBarrier` APIs.

An alternative would be to conservatively return true from the three
components.  That seems more likely to result in direct calls to these
member predicates, however, and at the moment at least there is no
reason for such calls to exist.  If some other caller besides the
deinit-barrier predicates needs to call this function, side-effect
analysis should be updated to cache these three properties separately at
that point.

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -98,30 +98,50 @@ public struct CalleeAnalysis {
   }
 }
 
-extension FullApplySite {
+extension Value {
   fileprivate func isBarrier(_ analysis: CalleeAnalysis) -> Bool {
-    guard let callees = analysis.getCallees(callee: callee) else {
+    guard let callees = analysis.getCallees(callee: self) else {
       return true
     }
     return callees.contains { $0.isDeinitBarrier }
   }
 }
 
-extension Instruction {
-  public final func maySynchronize(_ analysis: CalleeAnalysis) -> Bool {
-    if let site = self as? FullApplySite {
-      return site.isBarrier(analysis)
-    }
-    return maySynchronize
+extension FullApplySite {
+  fileprivate func isBarrier(_ analysis: CalleeAnalysis) -> Bool {
+    return callee.isBarrier(analysis)
+  }
+}
+
+extension EndApplyInst {
+  fileprivate func isBarrier(_ analysis: CalleeAnalysis) -> Bool {
+    return (operand.value.definingInstruction as! FullApplySite).isBarrier(analysis)
   }
+}
+
+extension AbortApplyInst {
+  fileprivate func isBarrier(_ analysis: CalleeAnalysis) -> Bool {
+    return (operand.value.definingInstruction as! FullApplySite).isBarrier(analysis)
+  }
+}
 
+extension Instruction {
   /// Whether lifetime ends of lexical values may safely be hoisted over this
   /// instruction.
   ///
   /// Deinitialization barriers constrain variable lifetimes. Lexical
   /// end_borrow, destroy_value, and destroy_addr cannot be hoisted above them.
   public final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {
-    return mayAccessPointer || mayLoadWeakOrUnowned || maySynchronize(analysis)
+    if let site = self as? FullApplySite {
+      return site.isBarrier(analysis)
+    }
+    if let eai = self as? EndApplyInst {
+      return eai.isBarrier(analysis)
+    }
+    if let aai = self as? AbortApplyInst {
+      return aai.isBarrier(analysis)
+    }
+    return mayAccessPointer || mayLoadWeakOrUnowned || maySynchronize
   }
 }
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -437,6 +437,8 @@ bool swift::isLetAddress(SILValue address) {
 //===----------------------------------------------------------------------===//
 
 bool swift::mayAccessPointer(SILInstruction *instruction) {
+  assert(!FullApplySite::isa(instruction) && !isa<EndApplyInst>(instruction) &&
+         !isa<AbortApplyInst>(instruction));
   if (!instruction->mayReadOrWriteMemory())
     return false;
   if (isa<BuiltinInst>(instruction)) {
@@ -455,6 +457,8 @@ bool swift::mayAccessPointer(SILInstruction *instruction) {
 }
 
 bool swift::mayLoadWeakOrUnowned(SILInstruction *instruction) {
+  assert(!FullApplySite::isa(instruction) && !isa<EndApplyInst>(instruction) &&
+         !isa<AbortApplyInst>(instruction));
   if (isa<BuiltinInst>(instruction)) {
     return instruction->mayReadOrWriteMemory();
   }
@@ -467,16 +471,19 @@ bool swift::mayLoadWeakOrUnowned(SILInstruction *instruction) {
 /// Conservatively, whether this instruction could involve a synchronization
 /// point like a memory barrier, lock or syscall.
 bool swift::maySynchronize(SILInstruction *instruction) {
+  assert(!FullApplySite::isa(instruction) && !isa<EndApplyInst>(instruction) &&
+         !isa<AbortApplyInst>(instruction));
   if (isa<BuiltinInst>(instruction)) {
     return instruction->mayReadOrWriteMemory();
   }
-  return FullApplySite::isa(instruction) 
-      || isa<EndApplyInst>(instruction)
-      || isa<AbortApplyInst>(instruction)
-      || isa<HopToExecutorInst>(instruction);
+  return isa<HopToExecutorInst>(instruction);
 }
 
 bool swift::mayBeDeinitBarrierNotConsideringSideEffects(SILInstruction *instruction) {
+  if (FullApplySite::isa(instruction) || isa<EndApplyInst>(instruction) ||
+      isa<AbortApplyInst>(instruction)) {
+    return true;
+  }
   bool retval = mayAccessPointer(instruction)
              || mayLoadWeakOrUnowned(instruction)
              || maySynchronize(instruction);