[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, 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`s specially first (to look up the side-effect and to
conservatively bail, respectively).  Asserted that the three component
predicates are not called with `FullApplySite`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 directly calls to these
member predicates, however, and at the moment at least there is no
reason for such calls to exist.

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -108,20 +108,16 @@ extension FullApplySite {
 }
 
 extension Instruction {
-  public final func maySynchronize(_ analysis: CalleeAnalysis) -> Bool {
-    if let site = self as? FullApplySite {
-      return site.isBarrier(analysis)
-    }
-    return maySynchronize
-  }
-
   /// 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)
+    }
+    return mayAccessPointer || mayLoadWeakOrUnowned || maySynchronize
   }
 }
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -437,6 +437,7 @@ bool swift::isLetAddress(SILValue address) {
 //===----------------------------------------------------------------------===//
 
 bool swift::mayAccessPointer(SILInstruction *instruction) {
+  assert(!FullApplySite::isa(instruction));
   if (!instruction->mayReadOrWriteMemory())
     return false;
   if (isa<BuiltinInst>(instruction)) {
@@ -455,6 +456,7 @@ bool swift::mayAccessPointer(SILInstruction *instruction) {
 }
 
 bool swift::mayLoadWeakOrUnowned(SILInstruction *instruction) {
+  assert(!FullApplySite::isa(instruction));
   return isa<LoadWeakInst>(instruction) 
       || isa<LoadUnownedInst>(instruction) 
       || isa<StrongCopyUnownedValueInst>(instruction)
@@ -464,13 +466,17 @@ 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));
   return FullApplySite::isa(instruction) 
       || isa<EndApplyInst>(instruction)
       || isa<AbortApplyInst>(instruction)
       || isa<HopToExecutorInst>(instruction);
 }
 
 bool swift::mayBeDeinitBarrierNotConsideringSideEffects(SILInstruction *instruction) {
+  if (FullApplySite::isa(instruction)) {
+    return true;
+  }
   bool retval = mayAccessPointer(instruction)
              || mayLoadWeakOrUnowned(instruction)
              || maySynchronize(instruction);