Optimizer: support statically initialized globals which contain pointers to other globals

For example:
```
  var p = Point(x: 10, y: 20)
  let o = UnsafePointer(&p)
```

Also support outlined arrays with pointers to other globals. For example:
```
var g1 = 1
var g2 = 2

func f() -> [UnsafePointer<Int>] {
  return [UnsafePointer(&g1), UnsafePointer(&g2)]
}
```

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -65,6 +65,12 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
 
   _ = cloner.clone(storeToGlobal.source)
 
+  // The initial value can contain a `begin_access` if it references another global variable by address, e.g.
+  //   var p = Point(x: 10, y: 20)
+  //   let o = UnsafePointer(&p)
+  //
+  allocInst.global.stripAccessInstructionFromInitializer(context)
+
   context.erase(instruction: allocInst)
   context.erase(instruction: storeToGlobal)
   context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
@@ -94,21 +100,19 @@ private func getGlobalInitialization(of function: Function) -> (allocInst: Alloc
     switch inst {
     case is ReturnInst,
          is DebugValueInst,
-         is DebugStepInst:
+         is DebugStepInst,
+         is BeginAccessInst,
+         is EndAccessInst:
       break
     case let agi as AllocGlobalInst:
       if allocInst != nil {
         return nil
       }
       allocInst = agi
     case let ga as GlobalAddrInst:
-      if globalAddr != nil {
-        return nil
-      }
-      guard let agi = allocInst, agi.global == ga.global else {
-        return nil
+      if let agi = allocInst, agi.global == ga.global {
+        globalAddr = ga
       }
-      globalAddr = ga
     case let si as StoreInst:
       if store != nil {
         return nil

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -302,6 +302,12 @@ private func constructObject(of allocRef: AllocRefInstBase,
     }
   }
   globalBuilder.createObject(type: allocRef.type, arguments: objectArgs, numBaseElements: storesToClassFields.count)
+
+  // The initial value can contain a `begin_access` if it references another global variable by address, e.g.
+  //   var p = Point(x: 10, y: 20)
+  //   let a = [UnsafePointer(&p)]
+  //
+  global.stripAccessInstructionFromInitializer(context)
 }
 
 private func replace(object allocRef: AllocRefInstBase,
@@ -339,6 +345,9 @@ private extension Value {
     guard let svi = self as? SingleValueInstruction else {
       return false
     }
+    if let beginAccess = svi as? BeginAccessInst {
+      return beginAccess.address.isValidGlobalInitValue
+    }
     if !svi.isValidInStaticInitializerOfGlobal {
       return false
     }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -431,3 +431,31 @@ extension FullApplySite {
     return false
   }
 }
+
+extension GlobalVariable {
+  /// Removes all `begin_access` and `end_access` instructions from the initializer.
+  ///
+  /// Access instructions are not allowed in the initializer, because the initializer must not contain
+  /// instructions with side effects (initializer instructions are not executed).
+  /// Exclusivity checking does not make sense in the initializer.
+  ///
+  /// The initializer functions of globals, which reference other globals by address, contain access
+  /// instructions. After the initializing code is copied to the global's initializer, those access
+  /// instructions must be stripped.
+  func stripAccessInstructionFromInitializer(_ context: FunctionPassContext) {
+    guard let initInsts = staticInitializerInstructions else {
+      return
+    }
+    for initInst in initInsts {
+      switch initInst {
+      case let beginAccess as BeginAccessInst:
+        beginAccess.uses.replaceAll(with: beginAccess.address, context)
+        context.erase(instruction: beginAccess)
+      case let endAccess as EndAccessInst:
+        context.erase(instruction: endAccess)
+      default:
+        break
+      }
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -145,7 +145,9 @@ extension Instruction {
          is ObjectInst,
          is ValueToBridgeObjectInst,
          is ConvertFunctionInst,
-         is ThinToThickFunctionInst:
+         is ThinToThickFunctionInst,
+         is AddressToPointerInst,
+         is GlobalAddrInst:
       return true
     default:
       return false

lib/IRGen/GenConstant.cpp

@@ -379,6 +379,20 @@ Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
     llvm::Type *ty = IGM.getTypeInfo(FRI->getType()).getStorageType();
     fnPtr = llvm::ConstantExpr::getBitCast(fnPtr, ty);
     return fnPtr;
+  } else if (auto *gAddr = dyn_cast<GlobalAddrInst>(operand)) {
+    SILGlobalVariable *var = gAddr->getReferencedGlobal();
+    auto &ti = IGM.getTypeInfo(var->getLoweredType());
+    auto expansion = IGM.getResilienceExpansionForLayout(var);
+    assert(ti.isFixedSize(expansion));
+    if (ti.isKnownEmpty(expansion)) {
+      return llvm::ConstantPointerNull::get(IGM.OpaquePtrTy);
+    }
+
+    Address addr = IGM.getAddrOfSILGlobalVariable(var, ti, NotForDefinition);
+    return addr.getAddress();
+  } else if (auto *atp = dyn_cast<AddressToPointerInst>(operand)) {
+    auto *val = emitConstantValue(IGM, atp->getOperand()).claimNextConstant();
+    return val;
   } else {
     llvm_unreachable("Unsupported SILInstruction in static initializer!");
   }

test/SILOptimizer/global_init_with_empty.swift

@@ -19,6 +19,9 @@ struct Mystruct {
   static var structglobal = Mystruct(a: 3, b: Empty(), c: 4)
   // CHECK: @{{[^ ]*tupleglobal[^ ]*}} = hidden global <{ %TSi, %TSi }> <{ %TSi <{ i{{[0-9]+}} 5 }>, %TSi <{ i{{[0-9]+}} 6 }> }>
   static var tupleglobal = (a: 5, b: Empty(), c: 6)
+
+  static var empty: () = ()
+  static var ptrToEmpty = UnsafePointer(&empty)
 }
 
 // CHECK-OUTPUT:      3
@@ -33,3 +36,6 @@ print(Mystruct.tupleglobal.a)
 print(Mystruct.tupleglobal.b)
 // CHECK-OUTPUT-NEXT: 6
 print(Mystruct.tupleglobal.c)
+// CHECK-OUTPUT-NEXT: {{0x0+$}}
+print(Mystruct.ptrToEmpty)
+

test/SILOptimizer/init_static_globals.sil

@@ -91,6 +91,13 @@ sil_global [let] @g5 : $TwoFields
 sil_global [let] @g6 : $TwoFields
 sil_global [let] @g7 : $TwoFields
 
+// CHECK-LABEL: sil_global [let] @g8 : $UnsafePointer<Int32> = {
+// CHECK-NEXT:    %0 = global_addr @g1 : $*Int32
+// CHECK-NEXT:    %1 = address_to_pointer %0 : $*Int32 to $Builtin.RawPointer
+// CHECK-NEXT:    %initval = struct $UnsafePointer<Int32> (%1 : $Builtin.RawPointer)
+// CHECK-NEXT:  }
+sil_global [let] @g8 : $UnsafePointer<Int32>
+
 // CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_trivialglobal_func :
 // CHECK-NOT:     alloc_global
 // CHECK-NOT:     store
@@ -246,3 +253,21 @@ bb0:
   return %10 : $()
 }
 
+// CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_pointer_to_other_global :
+// CHECK-NOT:     alloc_global
+// CHECK-NOT:     store
+// CHECK:       } // end sil function 'globalinit_pointer_to_other_global'
+sil [global_init_once_fn] [ossa] @globalinit_pointer_to_other_global : $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @g8
+  %2 = global_addr @g8 : $*UnsafePointer<Int32>
+  %3 = global_addr @g1 : $*Int32
+  %4 = begin_access [read] [dynamic] %3 : $*Int32
+  %5 = address_to_pointer %4 : $*Int32 to $Builtin.RawPointer
+  end_access %4 : $*Int32
+  %7 = struct $UnsafePointer<Int32> (%5 : $Builtin.RawPointer)
+  store %7 to [trivial] %2 : $*UnsafePointer<Int32>
+  %8 = tuple ()
+  return %8 : $()
+}
+

test/SILOptimizer/objectoutliner.sil

@@ -13,6 +13,11 @@ class Obj : Base {
   @_hasStorage var value: Int64
 }
 
+sil_global [let] @g1 : $Int32 = {
+  %0 = integer_literal $Builtin.Int32, 1
+  %initval = struct $Int32 (%0 : $Builtin.Int32)
+}
+
 // CHECK-LABEL: sil_global private @outline_global_simpleTv_ : $Obj = {
 // CHECK-NEXT:    %0 = integer_literal $Builtin.Int64, 1
 // CHECK-NEXT:    %1 = struct $Int64 (%0 : $Builtin.Int64)
@@ -47,6 +52,15 @@ class Obj : Base {
 // CHECK-NEXT:    %initval = object $Obj (%1 : $Int64, [tail_elems] %6 : $(Int64, Bool), %11 : $(Int64, Bool), %13 : $(Int64, Bool))
 // CHECK-NEXT:  }
 
+// CHECK-LABEL: sil_global private @outline_global_addressTv_ : $Obj = {
+// CHECK-NEXT:    %0 = integer_literal $Builtin.Int64, 1
+// CHECK-NEXT:    %1 = struct $Int64 (%0 : $Builtin.Int64)
+// CHECK-NEXT:    %2 = global_addr @g1 : $*Int32
+// CHECK-NEXT:    %3 = address_to_pointer %2 : $*Int32 to $Builtin.RawPointer
+// CHECK-NEXT:    %4 = struct $UnsafePointer<Int32> (%3 : $Builtin.RawPointer)
+// CHECK-NEXT:    %initval = object $Obj (%1 : $Int64, [tail_elems] %4 : $UnsafePointer<Int32>)
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: sil @outline_global_simple
 // CHECK: [[G:%[0-9]+]] = global_value @outline_global_simpleTv_ : $Obj
 // CHECK: strong_retain [[G]] : $Obj
@@ -343,3 +357,29 @@ bb0:
   return %33 : $Obj
 }
 
+// CHECK-LABEL: sil @outline_global_address :
+// CHECK:         [[G:%[0-9]+]] = global_value @outline_global_addressTv_ : $Obj
+// CHECK:         strong_retain [[G]] : $Obj
+// CHECK-NOT:     store
+// CHECK:       } // end sil function 'outline_global_address'
+sil @outline_global_address : $@convention(thin) () -> () {
+bb0:
+  %0 = integer_literal $Builtin.Word, 1
+  %1 = integer_literal $Builtin.Int64, 1
+  %4 = struct $Int64 (%1 : $Builtin.Int64)
+  %7 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
+  %9 = ref_element_addr %7 : $Obj, #Obj.value
+  store %4 to %9 : $*Int64
+  %11 = ref_tail_addr %7 : $Obj, $UnsafePointer<Int32>
+  %12 = global_addr @g1 : $*Int32
+  %13 = begin_access [read] [dynamic] %12 : $*Int32
+  %14 = address_to_pointer %13 : $*Int32 to $Builtin.RawPointer
+  end_access %13 : $*Int32
+  %16 = struct $UnsafePointer<Int32> (%14 : $Builtin.RawPointer)
+  store %16 to %11 : $*UnsafePointer<Int32>
+  %18 = end_cow_mutation %7 : $Obj
+  strong_release %18 : $Obj
+  %r = tuple ()
+  return %r : $()
+}
+

test/SILOptimizer/performance-annotations.swift

@@ -377,3 +377,11 @@ func testNestedGenericStruct() -> NestedGenericStruct<Int> {
   return nestedGeneric
 }
 
+var x = 24
+let pointerToX = UnsafePointer(&x)
+
+@_noLocks
+func testPointerToX() -> UnsafePointer<Int> {
+  return pointerToX
+}
+

test/SILOptimizer/static_arrays.swift

@@ -202,6 +202,17 @@ func functionArray() -> [(Int) -> Int] {
   return [foo, bar, { $0 + 10 }]
 }
 
+var g1 = 1
+var g2 = 2
+
+// CHECK-LABEL: sil {{.*arrayOfGlobalPointers.*}} : $@convention(thin) () -> @owned Array<UnsafePointer<Int>> {
+// CHECK:         global_value @{{.*arrayOfGlobalPointers.*}}
+// CHECK:       } // end sil function '{{.*arrayOfGlobalPointers.*}}'
+@inline(never)
+public func arrayOfGlobalPointers() -> [UnsafePointer<Int>] {
+  return [UnsafePointer(&g1), UnsafePointer(&g2)]
+}
+
 public struct FStr {
   // Not an array, but also tested here.
   public static var globalFunc = foo
@@ -239,6 +250,9 @@ func testit() {
   let sdict = returnStringDictionary()
   // CHECK-OUTPUT-NEXT: sdict 3: 2, 4, 6
   print("sdict \(sdict.count): \(sdict["1"]!), \(sdict["3"]!), \(sdict["5"]!)")
+
+  // CHECK-OUTPUT-NEXT: globalpointers: [1, 2]
+  print("globalpointers: \(arrayOfGlobalPointers().map { $0.pointee })")
 }
 
 testit()
@@ -253,17 +267,15 @@ func takeUnsafePointer(ptr : UnsafePointer<SwiftClass>, len: Int) {
 // This should be a single basic block, and the array should end up being stack
 // allocated.
 //
-// CHECK-LABEL: sil @{{.*}}passArrayOfClasses
-// CHECK: bb0(%0 : $SwiftClass, %1 : $SwiftClass, %2 : $SwiftClass):
-// CHECK-NOT: bb1(
-// CHECK: alloc_ref{{(_dynamic)?}} {{.*}}[tail_elems $SwiftClass *
-// CHECK-NOT: bb1(
-// CHECK:   return
+// CHECK-LABEL: sil [noinline] @{{.*passArrayOfClasses.*}} : $@convention(thin) (@guaranteed SwiftClass, @guaranteed SwiftClass, @guaranteed SwiftClass) -> () {
+// CHECK:       bb0(%0 : $SwiftClass, %1 : $SwiftClass, %2 : $SwiftClass):
+// CHECK-NOT:   bb1(
+// CHECK:         alloc_ref{{(_dynamic)?}} {{.*}}[tail_elems $SwiftClass *
+// CHECK-NOT:   bb1(
+// CHECK:       } // end sil function '{{.*passArrayOfClasses.*}}'
+@inline(never)
 public func passArrayOfClasses(a: SwiftClass, b: SwiftClass, c: SwiftClass) {
   let arr = [a, b, c]
   takeUnsafePointer(ptr: arr, len: arr.count)
 }
 
-
-
-