alias analysis: compute more precise memory effects of builtin "once"

* Check if the address in question is even visible from outside the function
* Return the memory effects of the called function

Also, add a new API `Instruction.memoryEffects`, which is internally used by `mayReadFromMemory` et al.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -68,19 +68,17 @@ struct AliasAnalysis {
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
         let path = AliasAnalysis.getPtrOrAddressPath(for: val)
-        if let apply = inst as? ApplySite {
-          let effect = getMemoryEffect(of: apply, for: val, path: path, context)
-          switch (effect.read, effect.write) {
-            case (false, false): return .None
-            case (true, false):  return .MayRead
-            case (false, true):  return .MayWrite
-            case (true, true):   return .MayReadWrite
+        switch inst {
+        case let apply as ApplySite:
+          return getMemoryEffect(ofApply: apply, for: val, path: path, context).bridged
+        case let builtin as BuiltinInst:
+          return getMemoryEffect(ofBuiltin: builtin, for: val, path: path, context).bridged
+        default:
+          if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
+            return .MayReadWrite
           }
+          return .None
         }
-        if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
-          return .MayReadWrite
-        }
-        return .None
       },
 
       // isObjReleasedFn
@@ -121,7 +119,7 @@ struct AliasAnalysis {
   }
 }
 
-private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
+private func getMemoryEffect(ofApply apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
   let calleeAnalysis = context.calleeAnalysis
   let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis, isAddress: true)
   let memoryEffects: SideEffects.Memory
@@ -132,7 +130,7 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
     memoryEffects = result.memory
   } else {
     // `address` has unknown escapes. So we have to take the global effects of the called function(s).
-    memoryEffects = calleeAnalysis.getSideEffects(of: apply).memory
+    memoryEffects = calleeAnalysis.getSideEffects(ofApply: apply).memory
   }
   // Do some magic for `let` variables. Function calls cannot modify let variables.
   // The only exception is that the let variable is directly passed to an indirect out of the
@@ -144,14 +142,28 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
   return memoryEffects
 }
 
+private func getMemoryEffect(ofBuiltin builtin: BuiltinInst, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
+
+  switch builtin.id {
+  case .Once, .OnceWithContext:
+    if !address.at(path).isEscaping(using: AddressVisibleByBuiltinOnceVisitor(), context) {
+      return SideEffects.Memory()
+    }
+    let callee = builtin.operands[1].value
+    return context.calleeAnalysis.getSideEffects(ofCallee: callee).memory
+  default:
+    return builtin.memoryEffects
+  }
+}
+
 private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Ownership {
   let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis, isAddress: false)
   if let result = value.at(path).visit(using: visitor, context) {
     // The resulting effects are the argument effects to which `value` escapes to.
     return result.ownership
   } else {
     // `value` has unknown escapes. So we have to take the global effects of the called function(s).
-    return visitor.calleeAnalysis.getSideEffects(of: apply).ownership
+    return visitor.calleeAnalysis.getSideEffects(ofApply: apply).ownership
   }
 }
 
@@ -180,6 +192,11 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
   var followLoads: Bool { !isAddress }
 }
 
+private struct AddressVisibleByBuiltinOnceVisitor : EscapeVisitor {
+  var followTrivialTypes: Bool { true }
+  var followLoads: Bool { false }
+}
+
 /// Lets `ProjectedValue.isEscaping` return true if the value is "escaping" to the `target` instruction.
 private struct EscapesToInstructionVisitor : EscapeVisitor {
   let target: Instruction
@@ -229,3 +246,13 @@ private struct IsIndirectResultWalker: AddressDefUseWalker {
   }
 }
 
+private extension SideEffects.Memory {
+  var bridged: swift.MemoryBehavior {
+    switch (read, write) {
+      case (false, false): return .None
+      case (true, false):  return .MayRead
+      case (false, true):  return .MayWrite
+      case (true, true):   return .MayReadWrite
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -25,7 +25,7 @@ public struct CalleeAnalysis {
       // getMemBehaviorFn
       { (bridgedApply: BridgedInstruction, observeRetains: Bool, bca: BridgedCalleeAnalysis) -> swift.MemoryBehavior in
         let apply = bridgedApply.instruction as! ApplySite
-        let e = bca.analysis.getSideEffects(of: apply)
+        let e = bca.analysis.getSideEffects(ofApply: apply)
         return e.getMemBehavior(observeRetains: observeRetains)
       }
     )
@@ -60,8 +60,12 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the global (i.e. not argument specific) side effects of an apply.
-  public func getSideEffects(of apply: ApplySite) -> SideEffects.GlobalEffects {
-    guard let callees = getCallees(callee: apply.callee) else {
+  public func getSideEffects(ofApply apply: ApplySite) -> SideEffects.GlobalEffects {
+    return getSideEffects(ofCallee: apply.callee)
+  }
+
+  public func getSideEffects(ofCallee callee: Value) -> SideEffects.GlobalEffects {
+    guard let callees = getCallees(callee: callee) else {
       return .worstEffects
     }
 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -73,32 +73,24 @@ public class Instruction : CustomStringConvertible, Hashable {
     return mayTrap || mayWriteToMemory
   }
 
-  final public var mayReadFromMemory: Bool {
+  final public var memoryEffects: SideEffects.Memory {
     switch bridged.getMemBehavior() {
-      case .MayRead, .MayReadWrite, .MayHaveSideEffects:
-        return true
-      default:
-        return false
+    case .None:
+      return SideEffects.Memory()
+    case .MayRead:
+      return SideEffects.Memory(read: true)
+    case .MayWrite:
+      return SideEffects.Memory(write: true)
+    case .MayReadWrite, .MayHaveSideEffects:
+      return SideEffects.Memory(read: true, write: true)
+    default:
+      fatalError("invalid memory behavior")
     }
   }
 
-  final public var mayWriteToMemory: Bool {
-    switch bridged.getMemBehavior() {
-      case .MayWrite, .MayReadWrite, .MayHaveSideEffects:
-        return true
-      default:
-        return false
-    }
-  }
-
-  final public var mayReadOrWriteMemory: Bool {
-    switch bridged.getMemBehavior() {
-      case .MayRead, .MayWrite, .MayReadWrite, .MayHaveSideEffects:
-        return true
-      default:
-        return false
-    }
-  }
+  final public var mayReadFromMemory: Bool { memoryEffects.read }
+  final public var mayWriteToMemory: Bool { memoryEffects.write }
+  final public var mayReadOrWriteMemory: Bool { memoryEffects.read || memoryEffects.write }
 
   public final var mayRelease: Bool {
     return bridged.mayRelease()

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -314,34 +314,11 @@ MemBehavior MemoryBehaviorVisitor::visitMarkUnresolvedMoveAddrInst(
 }
 
 MemBehavior MemoryBehaviorVisitor::visitBuiltinInst(BuiltinInst *BI) {
-  // If our callee is not a builtin, be conservative and return may have side
-  // effects.
-  if (!BI) {
-    return MemBehavior::MayHaveSideEffects;
-  }
-
-  // If the builtin is read none, it does not read or write memory.
-  if (!BI->mayReadOrWriteMemory()) {
-    LLVM_DEBUG(llvm::dbgs() << "  Found apply of read none builtin. Returning"
-                               " None.\n");
-    return MemBehavior::None;
-  }
-
-  // If the builtin is side effect free, then it can only read memory.
-  if (!BI->mayHaveSideEffects()) {
-    LLVM_DEBUG(llvm::dbgs() << "  Found apply of side effect free builtin. "
-                               "Returning MayRead.\n");
-    return MemBehavior::MayRead;
+  MemBehavior mb = BI->getMemoryBehavior();
+  if (mb != MemBehavior::None) {
+    return AA->getMemoryBehaviorOfInst(V, BI);
   }
-
-  // FIXME: If the value (or any other values from the instruction that the
-  // value comes from) that we are tracking does not escape and we don't alias
-  // any of the arguments of the apply inst, we should be ok.
-
-  // Otherwise be conservative and return that we may have side effects.
-  LLVM_DEBUG(llvm::dbgs() << "  Found apply of side effect builtin. "
-                             "Returning MayHaveSideEffects.\n");
-  return MemBehavior::MayHaveSideEffects;
+  return MemBehavior::None;
 }
 
 MemBehavior MemoryBehaviorVisitor::visitTryApplyInst(TryApplyInst *AI) {

lib/SILOptimizer/UtilityPasses/MemBehaviorDumper.cpp

@@ -68,6 +68,7 @@ class MemBehaviorDumper : public SILModuleTransform {
     case SILInstructionKind::LoadInst:
     case SILInstructionKind::StoreInst:
     case SILInstructionKind::CopyAddrInst:
+    case SILInstructionKind::BuiltinInst:
       return true;
     default:
       return false;

test/SILOptimizer/mem-behavior.sil

@@ -980,3 +980,25 @@ bb0(%0 : $Builtin.Int32):
   return %r : $()
 }
 
+sil_global @gi : $Int
+sil @g_init : $@convention(c) () -> ()
+
+// CHECK-LABEL: @test_builtin_once
+// CHECK:       PAIR #0.
+// CHECK-NEXT:      %4 = builtin "once"(%0 : $Builtin.RawPointer, %3 : $@convention(c) () -> ()) : $()
+// CHECK-NEXT:      %1 = global_addr @gi : $*Int
+// CHECK-NEXT:    r=1,w=1
+// CHECK:       PAIR #1.
+// CHECK-NEXT:      %4 = builtin "once"(%0 : $Builtin.RawPointer, %3 : $@convention(c) () -> ()) : $()
+// CHECK-NEXT:      %2 = alloc_stack $Int
+// CHECK-NEXT:    r=0,w=0
+sil @test_builtin_once : $@convention(thin) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  %1 = global_addr @gi : $*Int
+  %2 = alloc_stack $Int
+  %3 = function_ref @g_init : $@convention(c) () -> ()
+  %4 = builtin "once"(%0 : $Builtin.RawPointer, %3 : $@convention(c) () -> ()) : $()
+  dealloc_stack %2 : $*Int
+  %6 = tuple ()
+  return %6 : $()
+}