ComputeSideEffects: handle program termination functions which are defined in the same module

This case was neglected. The fix can result in better side effect analysis, e.g. in the stdlib core module.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -70,7 +70,10 @@ let computeSideEffects = FunctionPass(name: "compute-side-effects") {
 
   // Finally replace the function's side effects.
   context.modifyEffects(in: function) { (effects: inout FunctionEffects) in
-    effects.sideEffects = SideEffects(arguments: collectedEffects.argumentEffects, global: collectedEffects.globalEffects)
+    let globalEffects = function.isProgramTerminationPoint ?
+                            collectedEffects.globalEffects.forProgramTerminationPoints
+                          : collectedEffects.globalEffects
+    effects.sideEffects = SideEffects(arguments: collectedEffects.argumentEffects, global: globalEffects)
   }
 }
 

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -161,12 +161,7 @@ extension Function {
       break
     }
     if isProgramTerminationPoint {
-      // We can ignore any memory writes in a program termination point, because it's not relevant
-      // for the caller. But we need to consider memory reads, otherwise preceding memory writes
-      // would be eliminated by dead-store-elimination in the caller. E.g. String initialization
-      // for error strings which are printed by the program termination point.
-      // Regarding ownership: a program termination point must not touch any reference counted objects.
-      return SideEffects.GlobalEffects(memory: SideEffects.Memory(read: true))
+      return SideEffects.GlobalEffects.worstEffects.forProgramTerminationPoints
     }
     var result = SideEffects.GlobalEffects.worstEffects
     switch effectAttribute {
@@ -568,6 +563,18 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
       return result
     }
 
+    /// Effects with all effects removed which are not relevant for program termination points (like `fatalError`).
+    public var forProgramTerminationPoints: GlobalEffects {
+      // We can ignore any memory writes in a program termination point, because it's not relevant
+      // for the caller. But we need to consider memory reads, otherwise preceding memory writes
+      // would be eliminated by dead-store-elimination in the caller. E.g. String initialization
+      // for error strings which are printed by the program termination point.
+      // Regarding ownership: a program termination point must not touch any reference counted objects.
+      // Also, the deinit-barrier effect is not relevant because functions like `fatalError` and `exit` are
+      // not accessing objects (except strings).
+      return GlobalEffects(memory: Memory(read: memory.read))
+    }
+
     public static var worstEffects: GlobalEffects {
       GlobalEffects(memory: .worstEffects, ownership: .worstEffects, allocates: true, isDeinitBarrier: true)
     }

test/SILOptimizer/side_effects.sil

@@ -680,6 +680,13 @@ bb0(%0 : $*X):
   return %r : $()
 }
 
+sil [_semantics "programtermination_point"] @exitfunc_defined : $@convention(thin) () -> Never {
+bb0:
+  %u = function_ref @unknown_func : $@convention(thin) () -> ()
+  %a = apply %u() : $@convention(thin) () -> ()
+  unreachable
+}
+
 // CHECK-LABEL: sil @call_noreturn
 // CHECK-NEXT:  [global: read]
 // CHECK-NEXT:  {{^[^[]}}
@@ -697,6 +704,23 @@ bb2:
   return %r : $()
 }
 
+// CHECK-LABEL: sil @call_defined_noreturn
+// CHECK-NEXT:  [global: read]
+// CHECK-NEXT:  {{^[^[]}}
+sil @call_defined_noreturn : $@convention(thin) () -> () {
+bb0:
+  cond_br undef, bb1, bb2
+
+bb1:
+  %u = function_ref @exitfunc_defined : $@convention(thin) () -> Never
+  %a = apply %u() : $@convention(thin) () -> Never
+  unreachable
+
+bb2:
+  %r = tuple ()
+  return %r : $()
+}
+
 // CHECK-LABEL: sil @call_readnone
 // CHECK-NEXT:  [global: copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}