SILGen: Emit alloc_global when initializing global variables

It is still not clear to me when we access global variables from other
modules directly, versus using accessors; it seems to be controlled
by the -sil-serialize-all flag, rather than any language feature.

Until/if we add a @_fixed_layout equivalent for globals, I can't really
test direct access of globals from other modules; when we figure out
the story here I'll be able to add more tests and also tighten up
some isResilient() checks in the global code, but what's in there now
seems to work.

Author: slavapestov

lib/IRGen/GenInit.cpp

@@ -36,10 +36,9 @@ Address IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
   auto &ti = getTypeInfo(var->getLoweredType());
 
   // If the variable is empty, don't actually emit it; just return undef.
-  if (ti.isKnownEmpty()) {
+  if (ti.isFixedSize(ResilienceExpansion::Minimal) && ti.isKnownEmpty())
     return ti.getUndefAddress();
-  }
-  
+
   /// Get the global variable.
   Address addr = getAddrOfSILGlobalVariable(var, ti,
                      var->isDefinition() ? ForDefinition : NotForDefinition);

lib/IRGen/IRGenSIL.cpp

@@ -1633,8 +1633,9 @@ void IRGenSILFunction::visitGlobalAddrInst(GlobalAddrInst *i) {
   assert(loweredTy == i->getType().getObjectType());
   auto &ti = getTypeInfo(loweredTy);
 
-  // If the variable is empty, don't actually emit it; just return undef.
-  if (ti.isKnownEmpty()) {
+  // If the variable is universally fixed-size and known to be empty, don't
+  // actually emit a symbol for the global at all, just return undef.
+  if (ti.isFixedSize(ResilienceExpansion::Minimal) && ti.isKnownEmpty()) {
     setLoweredAddress(SILValue(i, 0), ti.getUndefAddress());
     return;
   }

lib/SILGen/SILGenDecl.cpp

@@ -918,6 +918,7 @@ InitializationPtr SILGenFunction::emitInitializationForVarDecl(VarDecl *vd) {
   InitializationPtr Result;
   if (!vd->getDeclContext()->isLocalContext()) {
     auto *silG = SGM.getSILGlobalVariable(vd, NotForDefinition);
+    B.createAllocGlobal(vd, silG);
     SILValue addr = B.createGlobalAddr(vd, silG);
     if (isUninitialized)
       addr = B.createMarkUninitializedVar(vd, addr);

test/Inputs/resilient_global.swift

@@ -0,0 +1,9 @@
+public struct EmptyResilientStruct {
+  public init() {}
+
+  public var computed: Int {
+    return 1337
+  }
+}
+
+public var emptyGlobal = EmptyResilientStruct()

test/Interpreter/global_resilience.swift

@@ -0,0 +1,86 @@
+// RUN: rm -rf %t && mkdir %t
+// RUN: %target-build-swift -emit-library -I %t -Xfrontend -enable-resilience -c %S/../Inputs/resilient_global.swift -o %t/resilient_global.o
+// RUN: %target-build-swift -emit-module -I %t -Xfrontend -enable-resilience -c %S/../Inputs/resilient_global.swift -o %t/resilient_global.o
+// RUN: %target-build-swift -emit-library -I %t -Xfrontend -enable-resilience -c %S/../Inputs/resilient_struct.swift -o %t/resilient_struct.o
+// RUN: %target-build-swift -emit-module -I %t -Xfrontend -enable-resilience -c %S/../Inputs/resilient_struct.swift -o %t/resilient_struct.o
+// RUN: %target-build-swift %s -Xlinker %t/resilient_global.o -Xlinker %t/resilient_struct.o -I %t -L %t -o %t/main
+// RUN: %target-run %t/main
+
+import StdlibUnittest
+import resilient_global
+import resilient_struct
+
+var ResilientGlobalTestSuite = TestSuite("ResilientGlobal")
+
+//
+// Fits inside a buffer's inline storage.
+//
+
+public struct MySmallResilientStruct {
+  let x: Int32
+}
+
+let mySmallGlobal = MySmallResilientStruct(x: 1)
+
+ResilientGlobalTestSuite.test("MySmallGlobal") {
+  expectEqual(1, mySmallGlobal.x)
+}
+
+//
+// Requires out-of-line allocation.
+//
+
+public struct MyLargeResilientStruct {
+  let w: Int64
+  let x: Int64
+  let y: Int64
+  let z: Int64
+}
+
+var myLargeGlobal = MyLargeResilientStruct(w: 1, x: 2, y: 3, z: 4)
+
+ResilientGlobalTestSuite.test("MyLargeGlobal") {
+  expectEqual(1, myLargeGlobal.w)
+  expectEqual(2, myLargeGlobal.x)
+  expectEqual(3, myLargeGlobal.y)
+  expectEqual(4, myLargeGlobal.z)
+
+  myLargeGlobal = MyLargeResilientStruct(w: 5, x: 6, y: 7, z: 8)
+  expectEqual(5, myLargeGlobal.w)
+  expectEqual(6, myLargeGlobal.x)
+  expectEqual(7, myLargeGlobal.y)
+  expectEqual(8, myLargeGlobal.z)
+}
+
+let myLargeGlobalUninitialized: MyLargeResilientStruct
+
+myLargeGlobalUninitialized = MyLargeResilientStruct(w: 9, x: 10, y: 11, z: 12)
+
+ResilientGlobalTestSuite.test("MyLargeGlobal") {
+  expectEqual(9, myLargeGlobalUninitialized.w)
+  expectEqual(10, myLargeGlobalUninitialized.x)
+  expectEqual(11, myLargeGlobalUninitialized.y)
+  expectEqual(12, myLargeGlobalUninitialized.z)
+}
+
+//
+// Unknown size -- must call value witness functions for buffer
+// management.
+//
+
+let myOtherGlobal = Size(w: 10, h: 15)
+
+ResilientGlobalTestSuite.test("MyOtherGlobal") {
+  expectEqual(10, myOtherGlobal.w)
+  expectEqual(15, myOtherGlobal.h)
+}
+
+//
+// Global variable is itself defined in a different module.
+//
+
+ResilientGlobalTestSuite.test("OtherGlobal") {
+  expectEqual(1337, emptyGlobal.computed)
+}
+
+runAllTests()

test/SILGen/lazy_globals.swift

@@ -1,8 +1,10 @@
 // RUN: %target-swift-frontend -parse-as-library -emit-silgen %s | FileCheck %s
 
 // CHECK: sil private @globalinit_[[T:.*]]_func0 : $@convention(thin) () -> () {
+// CHECK:   alloc_global @_Tv12lazy_globals1xSi
 // CHECK:   [[XADDR:%.*]] = global_addr @_Tv12lazy_globals1xSi : $*Int
 // CHECK:   store {{%.*}} to [[XADDR]] : $*Int
+
 // CHECK: sil hidden [global_init] @_TF12lazy_globalsau1xSi : $@convention(thin) () -> Builtin.RawPointer {
 // CHECK:   [[TOKEN_ADDR:%.*]] = global_addr @globalinit_[[T]]_token0 : $*Builtin.Word
 // CHECK:   [[TOKEN_PTR:%.*]] = address_to_pointer [[TOKEN_ADDR]] : $*Builtin.Word to $Builtin.RawPointer
@@ -14,8 +16,21 @@
 // CHECK: }
 var x: Int = 0
 
+// CHECK: sil private @globalinit_[[T:.*]]_func1 : $@convention(thin) () -> () {
+// CHECK:   alloc_global @_TZvV12lazy_globals3Foo3fooSi
+// CHECK:   [[XADDR:%.*]] = global_addr @_TZvV12lazy_globals3Foo3fooSi : $*Int
+// CHECK:   store {{.*}} to [[XADDR]] : $*Int
+// CHECK:   return
+
 struct Foo {
 // CHECK: sil hidden [global_init] @_TFV12lazy_globals3Fooau3fooSi : $@convention(thin) () -> Builtin.RawPointer {
+// CHECK:   [[TOKEN_ADDR:%.*]] = global_addr @globalinit_[[T]]_token1 : $*Builtin.Word
+// CHECK:   [[TOKEN_PTR:%.*]] = address_to_pointer [[TOKEN_ADDR]] : $*Builtin.Word to $Builtin.RawPointer
+// CHECK:   [[INIT_FUNC:%.*]] = function_ref @globalinit_[[T]]_func1 : $@convention(thin) () -> ()
+// CHECK:   builtin "once"([[TOKEN_PTR]] : $Builtin.RawPointer, [[INIT_FUNC]] : $@convention(thin) () -> ()) : $()
+// CHECK:   [[GLOBAL_ADDR:%.*]] = global_addr @_TZvV12lazy_globals3Foo3fooSi : $*Int
+// CHECK:   [[GLOBAL_PTR:%.*]] = address_to_pointer [[GLOBAL_ADDR]] : $*Int to $Builtin.RawPointer
+// CHECK:   return [[GLOBAL_PTR]] : $Builtin.RawPointer
   static var foo: Int = 22
 
   static var computed: Int {
@@ -25,8 +40,21 @@ struct Foo {
   static var initialized: Int = 57
 }
 
+// CHECK: sil private @globalinit_[[T:.*]]_func3 : $@convention(thin) () -> () {
+// CHECK:   alloc_global @_TZvO12lazy_globals3Bar3barSi
+// CHECK:   [[XADDR:%.*]] = global_addr @_TZvO12lazy_globals3Bar3barSi : $*Int
+// CHECK:   store {{.*}} to [[XADDR]] : $*Int
+// CHECK:   return
+
 enum Bar {
 // CHECK: sil hidden [global_init] @_TFO12lazy_globals3Barau3barSi : $@convention(thin) () -> Builtin.RawPointer {
+// CHECK:   [[TOKEN_ADDR:%.*]] = global_addr @globalinit_[[T]]_token3 : $*Builtin.Word
+// CHECK:   [[TOKEN_PTR:%.*]] = address_to_pointer [[TOKEN_ADDR]] : $*Builtin.Word to $Builtin.RawPointer
+// CHECK:   [[INIT_FUNC:%.*]] = function_ref @globalinit_[[T]]_func3 : $@convention(thin) () -> ()
+// CHECK:   builtin "once"([[TOKEN_PTR]] : $Builtin.RawPointer, [[INIT_FUNC]] : $@convention(thin) () -> ()) : $()
+// CHECK:   [[GLOBAL_ADDR:%.*]] = global_addr @_TZvO12lazy_globals3Bar3barSi : $*Int
+// CHECK:   [[GLOBAL_PTR:%.*]] = address_to_pointer [[GLOBAL_ADDR]] : $*Int to $Builtin.RawPointer
+// CHECK:   return [[GLOBAL_PTR]] : $Builtin.RawPointer
   static var bar: Int = 33
 }
 

test/SILGen/lazy_globals_multiple_vars.swift

@@ -1,7 +1,9 @@
 // RUN: %target-swift-frontend -parse-as-library -emit-silgen %s | FileCheck %s
 
 // CHECK:       sil private [[INIT_A_B:@globalinit_.*]] :
+// CHECK:         alloc_global @_Tv26lazy_globals_multiple_vars1aSi
 // CHECK:         global_addr @_Tv26lazy_globals_multiple_vars1aSi
+// CHECK:         alloc_global @_Tv26lazy_globals_multiple_vars1bSi
 // CHECK:         global_addr @_Tv26lazy_globals_multiple_vars1bSi
 // CHECK:       sil hidden [global_init] @_TF26lazy_globals_multiple_varsau1aSi
 // CHECK:         global_addr [[TOKEN_A_B:@globalinit_.*]] :
@@ -13,13 +15,15 @@ var (a, b) = (1, 2)
 
 // CHECK:       sil private [[INIT_C:@globalinit_.*]] :
 // CHECK-NOT:     global_addr @_Tv26lazy_globals_multiple_vars1dSi
+// CHECK:         alloc_global @_Tv26lazy_globals_multiple_vars1cSi
 // CHECK:         global_addr @_Tv26lazy_globals_multiple_vars1cSi
 // CHECK-NOT:     global_addr @_Tv26lazy_globals_multiple_vars1dSi
 // CHECK:       sil hidden [global_init] @_TF26lazy_globals_multiple_varsau1cSi
 // CHECK:         global_addr [[TOKEN_C:@globalinit_.*]] :
 // CHECK:         function_ref [[INIT_C]]
 // CHECK:       sil private [[INIT_D:@globalinit_.*]] :
 // CHECK-NOT:     global_addr @_Tv26lazy_globals_multiple_vars1cSi
+// CHECK:         alloc_global @_Tv26lazy_globals_multiple_vars1dSi
 // CHECK:         global_addr @_Tv26lazy_globals_multiple_vars1dSi
 // CHECK-NOT:     global_addr @_Tv26lazy_globals_multiple_vars1cSi
 // CHECK:       sil hidden [global_init] @_TF26lazy_globals_multiple_varsau1dSi

test/SILGen/properties.swift

@@ -566,7 +566,8 @@ func force_global_observing_property_setter() {
 // The property is initialized with "zero".
 // CHECK-LABEL: sil private @globalinit_{{.*}}_func1 : $@convention(thin) () -> () {
 // CHECK: bb0:
-// CHECK-NEXT: %0 = global_addr @_Tv10properties25global_observing_propertySi : $*Int
+// CHECK-NEXT: alloc_global @_Tv10properties25global_observing_propertySi
+// CHECK-NEXT: %1 = global_addr @_Tv10properties25global_observing_propertySi : $*Int
 // CHECK: properties.zero.unsafeMutableAddressor
 // CHECK: return
 

test/SILGen/toplevel.swift

@@ -11,6 +11,7 @@ func markUsed<T>(t: T) {}
 // CHECK: bb0({{%.*}} : $Int32, {{%.*}} : $UnsafeMutablePointer<UnsafeMutablePointer<Int8>>):
 
 // -- initialize x
+// CHECK: alloc_global @_Tv8toplevel1xSi
 // CHECK: [[X:%[0-9]+]] = global_addr @_Tv8toplevel1xSi : $*Int
 // CHECK: integer_literal $Builtin.Int2048, 999
 // CHECK: store {{.*}} to [[X]]
@@ -32,6 +33,7 @@ x = 0
 print_x()
 
 // <rdar://problem/19770775> Deferred initialization of let bindings rejected at top level in playground
+// CHECK: alloc_global @_Tv8toplevel5countSi
 // CHECK: [[COUNTADDR:%[0-9]+]] = global_addr @_Tv8toplevel5countSi : $*Int
 // CHECK-NEXT: [[COUNTMUI:%[0-9]+]] = mark_uninitialized [var] [[COUNTADDR]] : $*Int
 let count: Int
@@ -60,6 +62,7 @@ func print_y() {
 
 
 // -- assign y
+// CHECK: alloc_global @_Tv8toplevel1ySi
 // CHECK: [[Y1:%[0-9]+]] = global_addr @_Tv8toplevel1ySi : $*Int
 // CHECK: [[Y:%[0-9]+]] = mark_uninitialized [var] [[Y1]]
 // CHECK: assign {{.*}} to [[Y]]
@@ -81,7 +84,8 @@ guard let a = Optional(A()) else { trap() }
 markUsed(a)
 
 
-// CHECK: [[VARADDR:%[0-9]+]] = global_addr @_Tv8toplevel21NotInitializedIntegerSi
+// CHECK: alloc_global @_Tv8toplevel21NotInitializedIntegerSi
+// CHECK-NEXT: [[VARADDR:%[0-9]+]] = global_addr @_Tv8toplevel21NotInitializedIntegerSi
 // CHECK-NEXT: [[VARMUI:%[0-9]+]] = mark_uninitialized [var] [[VARADDR]] : $*Int
 // CHECK-NEXT: mark_function_escape [[VARMUI]] : $*Int