SILOptimizer: allow function pointers in static globals and static global arrays.

For example, generate a static global for the array literal in:

func foo(_ i: Int) -> Int { ... }
func bar(_ i: Int) -> Int { ... }

func returnFunctionArray() -> [(Int) -> Int] {
  return [foo, bar]
}

rdar://73570149
https://bugs.swift.org/browse/SR-14101

Author: eeckstein

lib/IRGen/GenConstant.cpp

@@ -216,6 +216,40 @@ llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
     auto *val = emitConstantValue(IGM, VTBI->getOperand());
     auto *sTy = IGM.getTypeInfo(VTBI->getType()).getStorageType();
     return llvm::ConstantExpr::getIntToPtr(val, sTy);
+
+  } else if (auto *CFI = dyn_cast<ConvertFunctionInst>(operand)) {
+    return emitConstantValue(IGM, CFI->getOperand());
+
+  } else if (auto *T2TFI = dyn_cast<ThinToThickFunctionInst>(operand)) {
+    SILType type = operand->getType();
+    auto *sTy = cast<llvm::StructType>(IGM.getTypeInfo(type).getStorageType());
+
+    auto *function = llvm::ConstantExpr::getBitCast(
+        emitConstantValue(IGM, T2TFI->getCallee()),
+        sTy->getTypeAtIndex((unsigned)0));
+
+    auto *context = llvm::ConstantExpr::getBitCast(
+        llvm::ConstantPointerNull::get(IGM.OpaquePtrTy),
+        sTy->getTypeAtIndex((unsigned)1));
+    
+    return llvm::ConstantStruct::get(sTy, {function, context});
+
+  } else if (auto *FRI = dyn_cast<FunctionRefInst>(operand)) {
+    SILFunction *fn = FRI->getReferencedFunction();
+
+    llvm::Constant *fnPtr = IGM.getAddrOfSILFunction(fn, NotForDefinition);
+    assert(!fn->isAsync() && "TODO: support async functions");
+
+    CanSILFunctionType fnType = FRI->getType().getAs<SILFunctionType>();
+    auto authInfo = PointerAuthInfo::forFunctionPointer(IGM, fnType);
+    if (authInfo.isSigned()) {
+      auto constantDiscriminator =
+          cast<llvm::Constant>(authInfo.getDiscriminator());
+      assert(!constantDiscriminator->getType()->isPointerTy());
+      fnPtr = IGM.getConstantSignedPointer(fnPtr, authInfo.getKey(), nullptr,
+        constantDiscriminator);
+    }
+    return fnPtr;
   } else {
     llvm_unreachable("Unsupported SILInstruction in static initializer!");
   }

lib/SIL/IR/SILGlobalVariable.cpp

@@ -170,12 +170,19 @@ bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I,
           return false;
       }
       return false;
+    case SILInstructionKind::FunctionRefInst:
+      // TODO: support async function pointers in static globals.
+      if (cast<FunctionRefInst>(I)->getReferencedFunction()->isAsync())
+        return false;
+      return true;
     case SILInstructionKind::StructInst:
     case SILInstructionKind::TupleInst:
     case SILInstructionKind::IntegerLiteralInst:
     case SILInstructionKind::FloatLiteralInst:
     case SILInstructionKind::ObjectInst:
     case SILInstructionKind::ValueToBridgeObjectInst:
+    case SILInstructionKind::ConvertFunctionInst:
+    case SILInstructionKind::ThinToThickFunctionInst:
       return true;
     default:
       return false;
@@ -310,13 +317,7 @@ swift::getVariableOfStaticInitializer(SILFunction *InitFunc,
       if (HasStore || SI->getDest() != SGA)
         return nullptr;
       HasStore = true;
-      SILValue value = SI->getSrc();
-
-      // We only handle StructInst and TupleInst being stored to a
-      // global variable for now.
-      if (!isa<StructInst>(value) && !isa<TupleInst>(value))
-        return nullptr;
-      InitVal = cast<SingleValueInstruction>(value);
+      InitVal = cast<SingleValueInstruction>(SI->getSrc());
     } else if (!SILGlobalVariable::isValidStaticInitializerInst(&I,
                                                              I.getModule())) {
       return nullptr;

test/SILOptimizer/static_arrays.swift

@@ -9,6 +9,11 @@
 
 // Check if the optimizer is able to convert array literals to statically initialized arrays.
 
+// CHECK-LABEL: sil_global @$s4test4FStrV10globalFuncyS2icvpZ : $@callee_guaranteed (Int) -> Int = {
+// CHECK:         %0 = function_ref @$s4test3fooyS2iF : $@convention(thin) (Int) -> Int
+// CHECK-NEXT:    %initval = thin_to_thick_function %0
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: outlined variable #0 of arrayLookup(_:)
 // CHECK-NEXT:  sil_global private @{{.*}}arrayLookup{{.*}} = {
 // CHECK-DAG:     integer_literal $Builtin.Int{{[0-9]+}}, 10
@@ -51,6 +56,20 @@
 // CHECK:         object {{.*}} ({{[^,]*}}, [tail_elems] {{[^,]*}}, {{[^,]*}})
 // CHECK-NEXT:  }
 
+// CHECK-LABEL: outlined variable #0 of functionArray()
+// CHECK-NEXT:  sil_global private @{{.*functionArray.*}} = {
+// CHECK:         function_ref
+// CHECK:         thin_to_thick_function
+// CHECK:         convert_function
+// CHECK:         function_ref
+// CHECK:         thin_to_thick_function
+// CHECK:         convert_function
+// CHECK:         function_ref
+// CHECK:         thin_to_thick_function
+// CHECK:         convert_function
+// CHECK:         object {{.*}} ({{[^,]*}}, [tail_elems]
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: outlined variable #0 of returnDictionary()
 // CHECK-NEXT:  sil_global private @{{.*}}returnDictionary{{.*}} = {
 // CHECK-DAG:     integer_literal $Builtin.Int{{[0-9]+}}, 5
@@ -154,6 +173,22 @@ public func returnStringDictionary() -> [String:String] {
   return ["1":"2", "3":"4", "5":"6"]
 }
 
+func foo(_ i: Int) -> Int { return i }
+
+// CHECK-LABEL: sil {{.*functionArray.*}} : $@convention(thin) () -> @owned Array<(Int) -> Int> {
+// CHECK:   global_value @{{.*functionArray.*}}
+// CHECK: } // end sil function '{{.*functionArray.*}}'
+@inline(never)
+func functionArray() -> [(Int) -> Int] {
+  func bar(_ i: Int) -> Int { return i + 1 }
+  return [foo, bar, { $0 + 10 }]
+}
+
+public struct FStr {
+  // Not an array, but also tested here.
+  public static var globalFunc = foo
+}
+
 // CHECK-OUTPUT:      [100, 101, 102]
 print(globalVariable)
 // CHECK-OUTPUT-NEXT: 11
@@ -168,6 +203,10 @@ print(gg!)
 storeArray()
 // CHECK-OUTPUT-NEXT: [227, 228]
 print(gg!)
+// CHECK-OUTPUT-NEXT: 311
+print(functionArray()[0](100) + functionArray()[1](100) + functionArray()[2](100))
+// CHECK-OUTPUT-NEXT: 27
+print(FStr.globalFunc(27))
 
 let dict = returnDictionary()
 // CHECK-OUTPUT-NEXT: dict 3: 2, 4, 6