SwiftCompilerSources: move some private utilities of passes into OptUtils

* `var Function.initializedGlobal`
* `func getGlobalInitialization`

and add `var CollectionLikeSequence.singleElement`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -441,17 +441,3 @@ private extension StoreInst {
     return false
   }
 }
-
-private extension Function {
-  var initializedGlobal: GlobalVariable? {
-    if !isGlobalInitOnceFunction {
-      return nil
-    }
-    for inst in entryBlock.instructions {
-      if let allocGlobal = inst as? AllocGlobalInst {
-        return allocGlobal.global
-      }
-    }
-    return nil
-  }
-}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -57,7 +57,9 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
   // Merge such individual stores to a single store of the whole struct.
   mergeStores(in: function, context)
 
-  guard let (allocInst, storeToGlobal) = getGlobalInitialization(of: function) else {
+  // The initializer must not contain a `global_value` because `global_value` needs to
+  // initialize the class metadata at runtime.
+  guard let (allocInst, storeToGlobal) = getGlobalInitialization(of: function, allowGlobalValue: false) else {
     return
   }
 
@@ -81,76 +83,6 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
   context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
 }
 
-/// Analyses the global initializer function and returns the `alloc_global` and `store`
-/// instructions which initialize the global.
-///
-/// The function's single basic block must contain following code pattern:
-/// ```
-///   alloc_global @the_global
-///   %a = global_addr @the_global
-///   %i = some_const_initializer_insts
-///   store %i to %a
-/// ```
-private func getGlobalInitialization(of function: Function) -> (allocInst: AllocGlobalInst, storeToGlobal: StoreInst)? {
-
-  guard let block = function.singleBlock else {
-    return nil
-  }
-
-  var allocInst: AllocGlobalInst? = nil
-  var globalAddr: GlobalAddrInst? = nil
-  var store: StoreInst? = nil
-
-  for inst in block.instructions {
-    switch inst {
-    case is ReturnInst,
-         is DebugValueInst,
-         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 let agi = allocInst, agi.global == ga.global {
-        globalAddr = ga
-      }
-    case let si as StoreInst:
-      if store != nil {
-        return nil
-      }
-      guard let ga = globalAddr else {
-        return nil
-      }
-      if si.destination != ga {
-        return nil
-      }
-      store = si
-    default:
-      if !inst.isValidInStaticInitializerOfGlobal {
-        return nil
-      }
-    }
-  }
-  if let store = store {
-    return (allocInst: allocInst!, storeToGlobal: store)
-  }
-  return nil
-}
-
-private extension Function {
-  var singleBlock: BasicBlock? {
-    let block = entryBlock
-    if block.next != nil {
-      return nil
-    }
-    return block
-  }
-}
-
 /// Merges stores to individual struct fields to a single store of the whole struct.
 ///
 ///   store %element1 to %element1Addr

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -484,6 +484,18 @@ extension Function {
     }
     return nil
   }
+
+  var initializedGlobal: GlobalVariable? {
+    if !isGlobalInitOnceFunction {
+      return nil
+    }
+    for inst in entryBlock.instructions {
+      if let allocGlobal = inst as? AllocGlobalInst {
+        return allocGlobal.global
+      }
+    }
+    return nil
+  }
 }
 
 extension FullApplySite {
@@ -570,3 +582,68 @@ extension InstructionRange {
     }
   }
 }
+
+/// Analyses the global initializer function and returns the `alloc_global` and `store`
+/// instructions which initialize the global.
+/// Returns nil if `function` has any side-effects beside initializing the global.
+///
+/// The function's single basic block must contain following code pattern:
+/// ```
+///   alloc_global @the_global
+///   %a = global_addr @the_global
+///   %i = some_const_initializer_insts
+///   store %i to %a
+/// ```
+func getGlobalInitialization(
+  of function: Function,
+  allowGlobalValue: Bool
+) -> (allocInst: AllocGlobalInst, storeToGlobal: StoreInst)? {
+  guard let block = function.blocks.singleElement else {
+    return nil
+  }
+
+  var allocInst: AllocGlobalInst? = nil
+  var globalAddr: GlobalAddrInst? = nil
+  var store: StoreInst? = nil
+
+  for inst in block.instructions {
+    switch inst {
+    case is ReturnInst,
+         is DebugValueInst,
+         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 let agi = allocInst, agi.global == ga.global {
+        globalAddr = ga
+      }
+    case let si as StoreInst:
+      if store != nil {
+        return nil
+      }
+      guard let ga = globalAddr else {
+        return nil
+      }
+      if si.destination != ga {
+        return nil
+      }
+      store = si
+    case is GlobalValueInst where allowGlobalValue:
+      break
+    default:
+      if !inst.isValidInStaticInitializerOfGlobal {
+        return nil
+      }
+    }
+  }
+  if let store = store {
+    return (allocInst: allocInst!, storeToGlobal: store)
+  }
+  return nil
+}

SwiftCompilerSources/Sources/SIL/Utilities/SequenceUtilities.swift

@@ -87,6 +87,17 @@ public protocol CollectionLikeSequence : FormattedLikeArray {
 
 public extension CollectionLikeSequence {
   var isEmpty: Bool { !contains(where: { _ in true }) }
+
+  var singleElement: Element? {
+    var singleElement: Element? = nil
+    for e in self {
+      if singleElement != nil {
+        return nil
+      }
+      singleElement = e
+    }
+    return singleElement
+  }
 }
 
 // Also make the lazy sequences a CollectionLikeSequence if the underlying sequence is one.