swift side effects: some additions and refactoring

add `Function.getSideEffects(forArgument:,atIndex:,withConvention:)`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -203,15 +203,17 @@ private struct CollectedEffects {
 
     if escapeWalker.hasUnknownUses(argument: argument) {
       // Worst case: we don't know anything about how the argument escapes.
-      addEffects(globalEffects.restrictedTo(argument: argument, withConvention: argument.convention), to: argument)
+      addEffects(globalEffects.restrictedTo(argument: argument.at(SmallProjectionPath(.anything)),
+                                            withConvention: argument.convention), to: argument)
 
     } else if escapeWalker.foundTakingLoad {
       // In most cases we can just ignore loads. But if the load is actually "taking" the
       // underlying memory allocation, we must consider this as a "destroy", because we don't
       // know what's happening with the loaded value. If there is any destroying instruction in the
       // function, it might be the destroy of the loaded value.
       let effects = SideEffects.GlobalEffects(ownership: globalEffects.ownership)
-      addEffects(effects.restrictedTo(argument: argument, withConvention: argument.convention), to: argument)
+      addEffects(effects.restrictedTo(argument: argument.at(SmallProjectionPath(.anything)),
+                                      withConvention: argument.convention), to: argument)
 
     } else if escapeWalker.foundConsumingPartialApply && globalEffects.ownership.destroy {
       // Similar situation with apply instructions which consume the callee closure.
@@ -236,7 +238,7 @@ private struct CollectedEffects {
       } else {
         // The callee doesn't have any computed effects. At least we can do better
         // if it has any defined effect attribute (like e.g. `[readnone]`).
-        globalEffects.merge(with: callee.definedSideEffects)
+        globalEffects.merge(with: callee.definedGlobalEffects)
       }
     }
 
@@ -252,15 +254,12 @@ private struct CollectedEffects {
           if let calleePath = calleeEffect.copy    { addEffects(.copy,    to: argument, fromInitialPath: calleePath) }
           if let calleePath = calleeEffect.destroy { addEffects(.destroy, to: argument, fromInitialPath: calleePath) }
         } else {
-          var calleeEffects = callee.definedSideEffects
-
           let convention = callee.getArgumentConvention(for: calleeArgIdx)
-          if convention.isIndirectIn {
-            calleeEffects.memory.read = true
-          } else if convention == .indirectOut {
-            calleeEffects.memory.write = true
-          }
-          addEffects(calleeEffects.restrictedTo(argument: argument, withConvention: convention), to: argument)
+          let wholeArgument = argument.at(SmallProjectionPath(.anything))
+          let calleeEffects = callee.getSideEffects(forArgument: wholeArgument,
+                                                    atIndex: calleeArgIdx,
+                                                    withConvention: convention)
+          addEffects(calleeEffects.restrictedTo(argument: wholeArgument, withConvention: convention), to: argument)
         }
       }
     }
@@ -274,7 +273,7 @@ private struct CollectedEffects {
     // deallocates an object.
     if let destructors = calleeAnalysis.getDestructors(of: addressOrValue.type) {
       for destructor in destructors {
-        globalEffects.merge(with: destructor.effects.accumulatedSideEffects)
+        globalEffects.merge(with: destructor.getSideEffects())
       }
     } else {
       globalEffects = .worstEffects

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -31,15 +31,6 @@ public struct FunctionEffects : CustomStringConvertible, NoReflectionChildren {
     self.sideEffects = nil
   }
 
-  /// The "accumulated" side-effects of the function, which includes the global effects and
-  /// all argument effects.
-  public var accumulatedSideEffects: SideEffects.GlobalEffects {
-    if let sideEffects = sideEffects {
-      return sideEffects.accumulatedEffects
-    }
-    return .worstEffects
-  }
-
   public var description: String {
     var numArgEffects = escapeEffects.arguments.reduce(0, { max($0, $1.argumentIndex) }) + 1
     if let sideEffects = sideEffects {
@@ -70,14 +61,77 @@ public struct FunctionEffects : CustomStringConvertible, NoReflectionChildren {
 
 extension Function {
 
-  /// The global side effects of the function which are defined by attributes.
+  /// Returns the global side effects of the function.
+  public func getSideEffects() -> SideEffects.GlobalEffects {
+    if let sideEffects = effects.sideEffects {
+      /// There are computed side effects.
+      return sideEffects.accumulatedEffects
+    } else {
+      
+      var effects = definedGlobalEffects
+
+      // Even a `[readnone]` function can read from indirect arguments.
+      if (0..<numArguments).contains(where: {getArgumentConvention(for: $0).isIndirectIn}) {
+        effects.memory.read = true
+      }
+      // Even `[readnone]` and `[readonly]` functions write to indirect results.
+      if numIndirectResultArguments > 0 {
+        effects.memory.write = true
+      }
+      return effects
+    }
+  }
+
+  /// Returns the side effects for a function argument.
   ///
-  /// This API should be used if there are no derived side-effects available, i.e. `effects.sideEffects` is nil.
-  /// It returns "worstEffects" unless an effect attribute (e.g. `[readnone]`) is set for the function.
-  public var definedSideEffects: SideEffects.GlobalEffects {
+  /// The `argument` can be a function argument in this function or an apply argument in a caller.
+  public func getSideEffects(forArgument argument: ProjectedValue,
+                             atIndex argumentIndex: Int,
+                             withConvention convention: ArgumentConvention) -> SideEffects.GlobalEffects {
+    if let sideEffects = effects.sideEffects {
+      /// There are computed side effects.
+      var result = SideEffects.GlobalEffects()
+      let argEffect = sideEffects.getArgumentEffects(for: argumentIndex)
+      if let effectPath = argEffect.read, effectPath.mayOverlap(with: argument.path) {
+        result.memory.read = true
+      }
+      if let effectPath = argEffect.write, effectPath.mayOverlap(with: argument.path) {
+        result.memory.write = true
+      }
+      if let effectPath = argEffect.copy, effectPath.mayOverlap(with: argument.path) {
+        result.ownership.copy = true
+      }
+      if let effectPath = argEffect.destroy, effectPath.mayOverlap(with: argument.path) {
+        result.ownership.destroy = true
+      }
+      return result
+    } else {
+      /// Even for defined effects, there might be additional effects due to the argument conventions.
+      var result = definedGlobalEffects
+      if convention.isIndirectIn {
+        // Even a `[readnone]` function can read from an indirect argument.
+        result.memory.read = true
+      } else if convention == .indirectOut {
+        // Even `[readnone]` and `[readonly]` functions write to indirect results.
+        result.memory.write = true
+      }
+      return result.restrictedTo(argument: argument, withConvention: convention)
+    }
+  }
+
+  /// Global effect of the function, defined by effect attributes.
+  public var definedGlobalEffects: SideEffects.GlobalEffects {
+    switch name {
+    case "_swift_stdlib_malloc_size", "_swift_stdlib_has_malloc_size":
+      // These C runtime functions, which are used in the array implementation, have defined effects.
+      return SideEffects.GlobalEffects(memory: SideEffects.Memory(read: true))
+    default:
+      break
+    }
     var result = SideEffects.GlobalEffects.worstEffects
     switch effectAttribute {
     case .none:
+      // The common case: there is no effect attribute, so we have to assume the worst effects.
       break
     case .readNone:
       result.memory.read = false
@@ -421,9 +475,9 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
     }
 
     /// Removes effects, which cannot occur for an `argument` value with a given `convention`.
-    public func restrictedTo(argument: Value, withConvention convention: ArgumentConvention) -> GlobalEffects {
+    public func restrictedTo(argument: ProjectedValue, withConvention convention: ArgumentConvention) -> GlobalEffects {
       var result = self
-      let isTrivial = argument.type.isTrivial(in: argument.function)
+      let isTrivial = argument.value.hasTrivialNonPointerType
       if isTrivial {
         // There cannot be any ownership effects on trivial arguments.
         result.ownership = SideEffects.Ownership()
@@ -439,14 +493,19 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
         result.ownership.copy = false
         result.ownership.destroy = false
 
-      // Note that `directGuaranteed` still has a "destroy" effect, because an object stored in
-      // a class property could be destroyed.
-      case .directOwned, .directUnowned, .directGuaranteed:
+      case .directGuaranteed:
+        // Note that `directGuaranteed` still has a "destroy" effect, because an object stored in
+        // a class property could be destroyed.
+        if argument.path.hasNoClassProjection {
+          result.ownership.destroy = false
+        }
+        fallthrough
+      case .directOwned, .directUnowned:
         if isTrivial {
           // Trivial direct arguments cannot have class properties which could be loaded from/stored to.
           result.memory = SideEffects.Memory()
         }
-        break
+
       case .indirectInout, .indirectInoutAliasable:
         break
       }