SIL: support statically initialized StaticString globals

The main part of the change is to support the ptr_to_int builtin in statically initialized globals. This builtin is used to build a StaticString from a string_literal.
On the other hand I removed the support of the FPTrunc builtin, which is not needed anyway (because it can be constant propagated).

include/swift/SIL/SILGlobalVariable.h

@@ -154,7 +154,8 @@ class SILGlobalVariable
 
   /// Returns true if \p I is a valid instruction to be contained in the
   /// static initializer.
-  static bool isValidStaticInitializerInst(const SILInstruction *I);
+  static bool isValidStaticInitializerInst(const SILInstruction *I,
+                                           SILModule &M);
 
   void dropAllReferences() {
     StaticInitializerBlock.dropAllReferences();

lib/IRGen/GenConstant.cpp

@@ -22,6 +22,7 @@
 #include "TypeInfo.h"
 #include "StructLayout.h"
 #include "swift/Basic/Range.h"
+#include "swift/SIL/SILModule.h"
 
 using namespace swift;
 using namespace irgen;
@@ -71,18 +72,24 @@ llvm::Constant *irgen::emitAddrOfConstantString(IRGenModule &IGM,
 }
 
 static llvm::Constant *emitConstantValue(IRGenModule &IGM, SILValue operand) {
-  if (auto *SI = dyn_cast<StructInst>(operand))
+  if (auto *SI = dyn_cast<StructInst>(operand)) {
     return emitConstantStruct(IGM, SI);
-  else if (auto *TI = dyn_cast<TupleInst>(operand))
+  } else if (auto *TI = dyn_cast<TupleInst>(operand)) {
     return emitConstantTuple(IGM, TI);
-  else if (auto *ILI = dyn_cast<IntegerLiteralInst>(operand))
+  } else if (auto *ILI = dyn_cast<IntegerLiteralInst>(operand)) {
     return emitConstantInt(IGM, ILI);
-  else if (auto *FLI = dyn_cast<FloatLiteralInst>(operand))
+  } else if (auto *FLI = dyn_cast<FloatLiteralInst>(operand)) {
     return emitConstantFP(IGM, FLI);
-  else if (auto *SLI = dyn_cast<StringLiteralInst>(operand))
+  } else if (auto *SLI = dyn_cast<StringLiteralInst>(operand)) {
     return emitAddrOfConstantString(IGM, SLI);
-  else
+  } else if (auto *BI = dyn_cast<BuiltinInst>(operand)) {
+    assert(IGM.getSILModule().getBuiltinInfo(BI->getName()).ID ==
+           BuiltinValueKind::PtrToInt);
+    llvm::Constant *ptr = emitConstantValue(IGM, BI->getArguments()[0]);
+    return llvm::ConstantExpr::getPtrToInt(ptr, IGM.IntPtrTy);
+  } else {
     llvm_unreachable("Unsupported SILInstruction in static initializer!");
+  }
 }
 
 namespace {

lib/SIL/SILGlobalVariable.cpp

@@ -76,12 +76,13 @@ SILInstruction *SILGlobalVariable::getStaticInitializerValue() {
   return &StaticInitializerBlock.back();
 }
 
-bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I) {
+bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I,
+                                                     SILModule &M) {
   switch (I->getKind()) {
     case ValueKind::BuiltinInst: {
       auto *bi = cast<BuiltinInst>(I);
-      switch (bi->getBuiltinInfo().ID) {
-        case BuiltinValueKind::FPTrunc:
+      switch (M.getBuiltinInfo(bi->getName()).ID) {
+        case BuiltinValueKind::PtrToInt:
           if (isa<LiteralInst>(bi->getArguments()[0]))
             return true;
           break;

lib/SIL/SILVerifier.cpp

@@ -4494,7 +4494,8 @@ void SILGlobalVariable::verify() const {
 
   // Verify the static initializer.
   for (const SILInstruction &I : StaticInitializerBlock) {
-    assert(isValidStaticInitializerInst(&I) && "illegal static initializer");
+    assert(isValidStaticInitializerInst(&I, getModule()) &&
+           "illegal static initializer");
     if (&I == &StaticInitializerBlock.back()) {
       assert(I.use_empty() && "Init value must not have another use");
     } else {

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -660,7 +660,8 @@ static SILGlobalVariable *getVariableOfStaticInitializer(SILFunction *InitFunc,
       // global variable for now.
       if (!isa<StructInst>(InitVal) && !isa<TupleInst>(InitVal))
         return nullptr;
-    } else if (!SILGlobalVariable::isValidStaticInitializerInst(&I)) {
+    } else if (!SILGlobalVariable::isValidStaticInitializerInst(&I,
+                                                             I.getModule())) {
       return nullptr;
     }
   }
@@ -1008,7 +1009,7 @@ static void getFields(ClassDecl *Cl, SmallVectorImpl<VarDecl *> &Fields) {
 /// all it's operands.
 static bool isValidInitVal(SILValue V) {
   if (SILInstruction *I = dyn_cast<SILInstruction>(V)) {
-    if (!SILGlobalVariable::isValidStaticInitializerInst(I))
+    if (!SILGlobalVariable::isValidStaticInitializerInst(I, I->getModule()))
       return false;
 
     for (Operand &Op : I->getAllOperands()) {

test/SILOptimizer/static_arrays.swift

@@ -30,6 +30,13 @@
 // CHECK:         object {{.*}} ({{[^,]*}}, [tail_elems] {{[^,]*}}, {{[^,]*}})
 // CHECK-NEXT:  }
 
+// CHECK-LABEL: outlined variable #0 of returnStaticStringArray()
+// CHECK-NEXT:  sil_global private @{{.*}}returnStaticStringArray{{.*}} = {
+// CHECK-DAG:     string_literal utf8 "a"
+// CHECK-DAG:     string_literal utf8 "b"
+// CHECK:         object {{.*}} ({{[^,]*}}, [tail_elems] {{[^,]*}}, {{[^,]*}})
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: outlined variable #0 of passArray()
 // CHECK-NEXT:  sil_global private @{{.*}}passArray{{.*}} = {
 // CHECK-DAG:     integer_literal $Builtin.Int{{[0-9]+}}, 27
@@ -80,6 +87,14 @@ public func returnArray() -> [Int] {
   return [20, 21]
 }
 
+// CHECK-LABEL: sil {{.*}}returnStaticStringArray{{.*}} : $@convention(thin) () -> @owned Array<StaticString> {
+// CHECK:   global_value @{{.*}}returnStaticStringArray{{.*}}
+// CHECK:   return
+@inline(never)
+public func returnStaticStringArray() -> [StaticString] {
+  return ["a", "b"]
+}
+
 public var gg: [Int]?
 
 @inline(never)
@@ -132,6 +147,8 @@ print(globalVariable)
 print(arrayLookup(1))
 // CHECK-OUTPUT-NEXT: [20, 21]
 print(returnArray())
+// CHECK-OUTPUT-NEXT: ["a", "b"]
+print(returnStaticStringArray())
 passArray()
 // CHECK-OUTPUT-NEXT: [29]
 print(gg!)