GlobalOpt: optimize static properties with resilient types.

For example:
struct ResilientStruct {
  var singleField: Int
  public static let x = ResilientStruct(singleField: 27)
}

The generated (resilient) getter for x should just return a 27 (wrapped in a struct) and not lazily initialize a global variable.

rdar://problem/46712028

Author: eeckstein

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -137,6 +137,9 @@ class SILGlobalOpt {
   /// can be statically initialized.
   void optimizeInitializer(SILFunction *AddrF, GlobalInitCalls &Calls);
 
+  /// Perform peephole optimizations on the initializer list.
+  void peepholeInitializer(SILFunction *InitFunc);
+
   /// Optimize access to the global variable, which is known to have a constant
   /// value. Replace all loads from the global address by invocations of a
   /// getter that returns the value of this variable.
@@ -253,12 +256,14 @@ static SILFunction *getGlobalGetterFunction(SILOptFunctionBuilder &FunctionBuild
   if (auto *F = M.lookUpFunction(getterNameTmp))
     return F;
 
-  auto Linkage = (varDecl->getEffectiveAccess() >= AccessLevel::Public
-                  ? SILLinkage::PublicNonABI
-                  : SILLinkage::Private);
-  auto Serialized = (varDecl->getEffectiveAccess() >= AccessLevel::Public
-                     ? IsSerialized
-                     : IsNotSerialized);
+  auto Linkage = SILLinkage::Private;
+  auto Serialized = IsNotSerialized;
+
+  if (varDecl->getEffectiveAccess() >= AccessLevel::Public &&
+      !varDecl->isResilient()) {
+    Linkage = SILLinkage::PublicNonABI;
+    Serialized = IsSerialized;
+  }
 
   auto refType = M.Types.getLoweredType(varDecl->getInterfaceType());
 
@@ -690,7 +695,17 @@ replaceLoadsByKnownValue(BuiltinInst *CallToOnce, SILFunction *AddrF,
       auto *PTAI = dyn_cast<PointerToAddressInst>(Use->getUser());
       assert(PTAI && "All uses should be pointer_to_address");
       for (auto PTAIUse : PTAI->getUses()) {
-        replaceLoadSequence(PTAIUse->getUser(), NewAI, B);
+        SILInstruction *Load = PTAIUse->getUser();
+        if (auto *CA = dyn_cast<CopyAddrInst>(Load)) {
+          // The result of the initializer is stored to another location.
+          SILBuilder B(CA);
+          B.createStore(CA->getLoc(), NewAI, CA->getDest(),
+                        StoreOwnershipQualifier::Unqualified);
+          CA->eraseFromParent();
+        } else {
+          // The result of the initializer is used as a value.
+          replaceLoadSequence(Load, NewAI, B);
+        }
       }
     }
 
@@ -721,6 +736,8 @@ void SILGlobalOpt::optimizeInitializer(SILFunction *AddrF,
       InitializerCount[InitF] > 1)
     return;
 
+  peepholeInitializer(InitF);
+
   // If the globalinit_func is trivial, continue; otherwise bail.
   SingleValueInstruction *InitVal;
   SILGlobalVariable *SILG = getVariableOfStaticInitializer(InitF, InitVal);
@@ -743,6 +760,58 @@ void SILGlobalOpt::optimizeInitializer(SILFunction *AddrF,
   HasChanged = true;
 }
 
+void SILGlobalOpt::peepholeInitializer(SILFunction *InitFunc) {
+  if (InitFunc->size() != 1)
+    return;
+  SILBasicBlock *BB = &InitFunc->front();
+
+  for (auto &I : *BB) {
+    if (auto *SI = dyn_cast<StoreInst>(&I)) {
+
+      // If struct S has a single field, replace
+      //   %a = struct_element_addr %s : $*S
+      //   store %x to %a
+      // with
+      //   %y = struct $S (%x)
+      //   store %y to %s
+      //
+      // This pattern occurs with resilient static properties, like
+      // struct ResilientStruct {
+      //   var singleField: Int
+      //   public static let x = ResilientStruct(singleField: 27)
+      // }
+      //
+      // TODO: handle structs with multiple fields.
+      SILValue Addr = SI->getDest();
+      auto *SEA = dyn_cast<StructElementAddrInst>(Addr);
+      if (!SEA)
+        continue;
+
+      if (SEA->getOperand()->getType().isAddressOnly(InitFunc))
+        continue;
+
+      StructDecl *Decl = SEA->getStructDecl();
+      auto beginProp = Decl->getStoredProperties().begin();
+      if (std::next(beginProp) != Decl->getStoredProperties().end())
+        continue;
+
+      assert(*beginProp == SEA->getField());
+
+      SILBuilder B(SI);
+      SILValue StructAddr = SEA->getOperand();
+      StructInst *Struct = B.createStruct(SEA->getLoc(),
+                                          StructAddr->getType().getObjectType(),
+                                          { SI->getSrc() });
+      SI->setOperand(StoreInst::Src, Struct);
+      SI->setOperand(StoreInst::Dest, StructAddr);
+      if (SEA->use_empty()) {
+        SEA->eraseFromParent();
+      }
+      HasChanged = true;
+    }
+  }
+}
+
 static bool canBeChangedExternally(SILGlobalVariable *SILG) {
   // Don't assume anything about globals which are imported from other modules.
   if (isAvailableExternally(SILG->getLinkage()))

test/SILOptimizer/globalopt_resilience.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-frontend  -O -module-name=test -enable-resilience -emit-sil -primary-file %s | %FileCheck %s
+
+// Check if GlobalOpt generates the optimal getter for a static property with a resilient type.
+// The (resilient) getter should just return the literal (and not lazily initialize a global variable).
+
+// CHECK-LABEL: sil @$s4test15ResilientStructV9staticValACvgZ :
+// CHECK:     bb0(%0 : $*ResilientStruct{{.*}}):
+// CHECK:       [[L:%[0-9]+]] = integer_literal {{.*}}, 27
+// CHECK:       [[I:%[0-9]+]] = struct $Int ([[L]] : {{.*}})
+// CHECK:       [[S:%[0-9]+]] = struct $ResilientStruct ([[I]] : $Int)
+// CHECK:       store [[S]] to %0
+// CHECK:       return
+
+public struct ResilientStruct {
+  var rawValue: Int
+
+  public static let staticVal = ResilientStruct(rawValue: 27)
+}
+