AliasAnalysis: handle global let-variables in ImmutableScope

Global let-variables are immutable, except in functions which initialize them.
This brings back handling of global let-variables in alias analysis, which was removed in the previous commit.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -615,6 +615,12 @@ private enum ImmutableScope {
           return nil
         }
         object = tailAddr.instance
+      case .global(let global):
+        if global.isLet && !basedAddress.parentFunction.canInitializeGlobal {
+          self = .wholeFunction
+          return
+        }
+        return nil
       default:
         return nil
       }
@@ -894,6 +900,14 @@ private extension Type {
   }
 }
 
+private extension Function {
+  var canInitializeGlobal: Bool {
+    return isGlobalInitOnceFunction ||
+           // In non -parse-as-library mode globals are initialized in the `main` function.
+           name == "main"
+  }
+}
+
 //===--------------------------------------------------------------------===//
 //                              Bridging
 //===--------------------------------------------------------------------===//

test/SILOptimizer/copy-to-borrow-optimization.sil

@@ -257,6 +257,29 @@ bb0(%x : @guaranteed $SubclassLet):
   return undef : $()
 }
 
+// CHECK-LABEL: sil [ossa] @dont_copy_let_global :
+// CHECK:         global_addr
+// CHECK-NEXT:    load_borrow
+// CHECK-NEXT:    begin_borrow
+// CHECK-NEXT:    apply
+// CHECK-NEXT:    end_borrow
+// CHECK-NEXT:    end_borrow
+// CHECK-NEXT:    return
+// CHECK-NEXT: } // end sil function 'dont_copy_let_global'
+sil [ossa] @dont_copy_let_global : $@convention(thin) () -> () {
+bb0:
+  %f = function_ref @black_hole : $@convention(thin) (@guaranteed Klass) -> ()
+
+  %p = global_addr @a_let_global : $*Klass
+  %v = load [copy] %p : $*Klass
+  %b = begin_borrow %v : $Klass
+  apply %f(%b) : $@convention(thin) (@guaranteed Klass) -> ()
+  end_borrow %b : $Klass
+  destroy_value %v : $Klass
+
+  return undef : $()
+}
+
 // CHECK-LABEL: sil [ossa] @dont_copy_let_properties_with_guaranteed_base_structural
 // CHECK:         ref_element_addr
 // CHECK-NEXT:    tuple_element_addr

test/SILOptimizer/mem-behavior.sil

@@ -841,12 +841,44 @@ bb0(%0 : $*C, %1 : $*C):
 sil_global hidden [let] @globalC : $C
 sil_global hidden @globalCVar : $C
 
+// CHECK-LABEL: @testGlobalLet
+// CHECK:      PAIR #1.
+// CHECK-NEXT:     %3 = apply %2() : $@convention(thin) () -> ()
+// CHECK-NEXT:     %0 = global_addr @globalC : $*C
+// CHECK-NEXT:   r=1,w=0
+sil hidden @testGlobalLet : $@convention(thin) () -> () {
+bb0:
+  %0 = global_addr @globalC : $*C
+  %1 = load %0 : $*C
+  %2 = function_ref @nouser_func : $@convention(thin) () -> ()
+  %3 = apply %2() : $@convention(thin) () -> ()
+  %4 = function_ref @read_C : $@convention(thin) (@in_guaranteed C) -> ()
+  %5 = apply %4(%0) : $@convention(thin) (@in_guaranteed C) -> ()
+  %8 = tuple ()
+  return %8 : $()
+}
+
 // CHECK-LABEL: @testInitGlobalLet
 // CHECK:      PAIR #0.
 // CHECK-NEXT:     %2 = apply %1(%0) : $@convention(thin) () -> @out C
 // CHECK-NEXT:     %0 = global_addr @globalC : $*C
 // CHECK-NEXT:   r=1,w=1
-sil hidden @testInitGlobalLet : $@convention(thin) () -> () {
+sil hidden [global_init_once_fn] @testInitGlobalLet : $@convention(thin) () -> () {
+bb0:
+  %0 = global_addr @globalC : $*C
+  %1 = function_ref @init_C : $@convention(thin) () -> @out C
+  %2 = apply %1(%0) : $@convention(thin) () -> @out C
+  %3 = load %0 : $*C
+  %8 = tuple ()
+  return %8 : $()
+}
+
+// CHECK-LABEL: @main
+// CHECK:      PAIR #0.
+// CHECK-NEXT:     %2 = apply %1(%0) : $@convention(thin) () -> @out C
+// CHECK-NEXT:     %0 = global_addr @globalC : $*C
+// CHECK-NEXT:   r=1,w=1
+sil [global_init_once_fn] @main : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalC : $*C
   %1 = function_ref @init_C : $@convention(thin) () -> @out C
@@ -885,6 +917,25 @@ bb0:
   return %1 : $Builtin.RawPointer
 }
 
+// CHECK-LABEL: @testGlobalViaAddressorLet
+// CHECK:      PAIR #2.
+// CHECK-NEXT:     %5 = apply %4() : $@convention(thin) () -> ()
+// CHECK-NEXT:     %2 = pointer_to_address %1 : $Builtin.RawPointer to [strict] $*C
+// CHECK-NEXT:   r=1,w=0
+sil @testGlobalViaAddressorLet : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @addressor_of_globalC : $@convention(thin) () -> Builtin.RawPointer
+  %1 = apply %0() : $@convention(thin) () -> Builtin.RawPointer
+  %2 = pointer_to_address %1 : $Builtin.RawPointer to [strict] $*C
+  %3 = load %2 : $*C
+  %4 = function_ref @nouser_func : $@convention(thin) () -> ()
+  %5 = apply %4() : $@convention(thin) () -> ()
+  %6 = function_ref @read_C : $@convention(thin) (@in_guaranteed C) -> ()
+  %7 = apply %6(%2) : $@convention(thin) (@in_guaranteed C) -> ()
+  %8 = tuple ()
+  return %8 : $()
+}
+
 // CHECK-LABEL: @testGlobalViaAddressorVar
 // CHECK:      PAIR #2.
 // CHECK-NEXT:     %5 = apply %4() : $@convention(thin) () -> ()