Optimizer/IRGen: allow enums in static initializers of globals

The main change here is in IRGen which needs to be able to emit constant enum values.
Use `emitValueInjection` to create the enum constant.
Usually this method creates code in the current function.
But if all arguments to the enum are constant, the builder never has to emit an instruction.
Instead it can constant fold everything and just returns the final constant.

Also, create statically initialized let-globals as constant global (`constant` instead of `global`).

Author: eeckstein

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -123,6 +123,7 @@ extension Instruction {
       return !fri.referencedFunction.isAsync
     case is StructInst,
          is TupleInst,
+         is EnumInst,
          is IntegerLiteralInst,
          is FloatLiteralInst,
          is ObjectInst,

lib/IRGen/Explosion.h

@@ -60,6 +60,10 @@ class Explosion {
     return *this;
   }
 
+  Explosion(llvm::Value *singleValue) : NextValue(0) {
+    add(singleValue);
+  }
+
   ~Explosion() {
     assert(empty() && "explosion had values remaining when destroyed!");
   }
@@ -133,6 +137,10 @@ class Explosion {
     return Values[NextValue++];
   }
 
+  llvm::Constant *claimNextConstant() {
+    return cast<llvm::Constant>(claimNext());
+  }
+
   /// Claim and return the next N values in this explosion.
   ArrayRef<llvm::Value*> claim(unsigned n) {
     assert(NextValue + n <= Values.size());

lib/IRGen/GenConstant.cpp

@@ -16,7 +16,10 @@
 
 #include "llvm/IR/Constants.h"
 
+#include "BitPatternReader.h"
+#include "Explosion.h"
 #include "GenConstant.h"
+#include "GenEnum.h"
 #include "GenIntegerLiteral.h"
 #include "GenStruct.h"
 #include "GenTuple.h"
@@ -115,43 +118,83 @@ llvm::Constant *irgen::emitAddrOfConstantString(IRGenModule &IGM,
 namespace {
 
 /// Fill in the missing values for padding.
-void insertPadding(SmallVectorImpl<llvm::Constant *> &Elements,
+void insertPadding(SmallVectorImpl<Explosion> &elements,
                    llvm::StructType *sTy) {
   // fill in any gaps, which are the explicit padding that swiftc inserts.
-  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
-    auto &elt = Elements[i];
-    if (elt == nullptr) {
+  for (unsigned i = 0, e = elements.size(); i != e; ++i) {
+    if (elements[i].empty()) {
       auto *eltTy = sTy->getElementType(i);
       assert(eltTy->isArrayTy() &&
              eltTy->getArrayElementType()->isIntegerTy(8) &&
              "Unexpected non-byte-array type for constant struct padding");
-      elt = llvm::UndefValue::get(eltTy);
+      elements[i].add(llvm::UndefValue::get(eltTy));
     }
   }
 }
 
+/// Creates a struct which contains all values of `explosions`.
+///
+/// If all explosions have a single element and those elements match the
+/// elements of `structTy`, it uses this type as result type.
+/// Otherwise, it creates an anonymous struct. This can be the case for enums.
+llvm::Constant *createStructFromExplosion(SmallVectorImpl<Explosion> &explosions,
+                                          llvm::StructType *structTy) {
+  assert(explosions.size() == structTy->getNumElements());
+  bool canUseStructType = true;
+  llvm::SmallVector<llvm::Constant *, 32> values;
+  unsigned idx = 0;
+  for (auto &elmt : explosions) {
+    if (elmt.size() != 1)
+      canUseStructType = false;
+    for (llvm::Value *v : elmt.claimAll()) {
+      if (v->getType() != structTy->getElementType(idx))
+        canUseStructType = false;
+      values.push_back(cast<llvm::Constant>(v));
+    }
+    idx++;
+  }
+  if (canUseStructType) {
+    return llvm::ConstantStruct::get(structTy, values);
+  } else {
+    return llvm::ConstantStruct::getAnon(values, /*Packed=*/ true);
+  }
+}
+
+void initWithEmptyExplosions(SmallVectorImpl<Explosion> &explosions,
+                             unsigned count) {
+  for (unsigned i = 0; i < count; i++) {
+    explosions.push_back(Explosion());
+  }
+}
+
 template <typename InstTy, typename NextIndexFunc>
-llvm::Constant *emitConstantStructOrTuple(IRGenModule &IGM, InstTy inst,
-                                          NextIndexFunc nextIndex) {
+Explosion emitConstantStructOrTuple(IRGenModule &IGM, InstTy inst,
+                                    NextIndexFunc nextIndex, bool flatten) {
   auto type = inst->getType();
   auto *sTy = cast<llvm::StructType>(IGM.getTypeInfo(type).getStorageType());
 
-  SmallVector<llvm::Constant *, 32> elts(sTy->getNumElements(), nullptr);
+  SmallVector<Explosion, 32> elements;
+  initWithEmptyExplosions(elements, sTy->getNumElements());
 
-  // run over the Swift initializers, putting them into the struct as
-  // appropriate.
   for (unsigned i = 0, e = inst->getElements().size(); i != e; ++i) {
     auto operand = inst->getOperand(i);
     Optional<unsigned> index = nextIndex(IGM, type, i);
     if (index.has_value()) {
-      assert(elts[index.value()] == nullptr &&
+      unsigned idx = index.value();
+      assert(elements[idx].empty() &&
              "Unexpected constant struct field overlap");
-
-      elts[index.value()] = emitConstantValue(IGM, operand);
+      elements[idx] = emitConstantValue(IGM, operand, flatten);
+    }
+  }
+  if (flatten) {
+    Explosion out;
+    for (auto &elmt : elements) {
+      out.add(elmt.claimAll());
     }
+    return out;
   }
-  insertPadding(elts, sTy);
-  return llvm::ConstantStruct::get(sTy, elts);
+  insertPadding(elements, sTy);
+  return createStructFromExplosion(elements, sTy);
 }
 } // end anonymous namespace
 
@@ -181,7 +224,36 @@ static BuiltinInst *getOffsetSubtract(const TupleExtractInst *TE, SILModule &M)
   return BI;
 }
 
-llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
+static bool isPowerOfTwo(unsigned x) {
+  return (x & -x) == x;
+}
+
+/// Replace i24, i40, i48 and i56 constants in `e` with the corresponding byte values.
+/// Such unaligned integer constants are not correctly layed out in the data section.
+static Explosion replaceUnalignedIntegerValues(IRGenModule &IGM, Explosion e) {
+  Explosion out;
+  while (!e.empty()) {
+    llvm::Value *v = e.claimNext();
+
+    if (auto *constInt = dyn_cast<llvm::ConstantInt>(v)) {
+      unsigned size = constInt->getBitWidth();
+      if (size % 8 == 0 && !isPowerOfTwo(size)) {
+        BitPatternReader reader(constInt->getValue(), IGM.Triple.isLittleEndian());
+        while (size > 0) {
+          APInt byte = reader.read(8);
+          out.add(llvm::ConstantInt::get(IGM.getLLVMContext(), byte));
+          size -= 8;
+        }
+        continue;
+      }
+    }
+    out.add(v);
+  }
+  return out;
+}
+
+Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
+                                   bool flatten) {
   if (auto *SI = dyn_cast<StructInst>(operand)) {
     // The only way to get a struct's stored properties (which we need to map to
     // their physical/LLVM index) is to iterate over the properties
@@ -195,64 +267,83 @@ llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
           (void)_i;
           auto *FD = *Iter++;
           return irgen::getPhysicalStructFieldIndex(IGM, Type, FD);
-        });
+        }, flatten);
   } else if (auto *TI = dyn_cast<TupleInst>(operand)) {
     return emitConstantStructOrTuple(IGM, TI,
-                                     irgen::getPhysicalTupleElementStructIndex);
+                                     irgen::getPhysicalTupleElementStructIndex,
+                                     flatten);
+  } else if (auto *ei = dyn_cast<EnumInst>(operand)) {
+    Explosion data;
+    if (ei->hasOperand()) {
+      data = emitConstantValue(IGM, ei->getOperand(), /*flatten=*/ true);
+    }
+    // Use `emitValueInjection` to create the enum constant.
+    // Usually this method creates code in the current function. But if all
+    // arguments to the enum are constant, the builder never has to emit an
+    // instruction. Instead it can constant fold everything and just returns
+    // the final constant.
+    Explosion out;
+    IRBuilder builder(IGM.getLLVMContext(), false);
+    getEnumImplStrategy(IGM, ei->getType())
+      .emitValueInjection(IGM, builder, ei->getElement(), data, out);
+    return replaceUnalignedIntegerValues(IGM, std::move(out));
   } else if (auto *ILI = dyn_cast<IntegerLiteralInst>(operand)) {
     return emitConstantInt(IGM, ILI);
   } else if (auto *FLI = dyn_cast<FloatLiteralInst>(operand)) {
     return emitConstantFP(IGM, FLI);
   } else if (auto *SLI = dyn_cast<StringLiteralInst>(operand)) {
     return emitAddrOfConstantString(IGM, SLI);
   } else if (auto *BI = dyn_cast<BuiltinInst>(operand)) {
+    auto args = BI->getArguments();
     switch (IGM.getSILModule().getBuiltinInfo(BI->getName()).ID) {
       case BuiltinValueKind::ZeroInitializer:
         return emitConstantZero(IGM, BI);
       case BuiltinValueKind::PtrToInt: {
-        llvm::Constant *ptr = emitConstantValue(IGM, BI->getArguments()[0]);
+        auto *ptr = emitConstantValue(IGM, args[0]).claimNextConstant();
         return llvm::ConstantExpr::getPtrToInt(ptr, IGM.IntPtrTy);
       }
       case BuiltinValueKind::ZExtOrBitCast: {
-        llvm::Constant *value = emitConstantValue(IGM, BI->getArguments()[0]);
-        return llvm::ConstantExpr::getZExtOrBitCast(value, IGM.getStorageType(BI->getType()));
+        auto *val = emitConstantValue(IGM, args[0]).claimNextConstant();
+        return llvm::ConstantExpr::getZExtOrBitCast(val,
+                                                    IGM.getStorageType(BI->getType()));
       }
       case BuiltinValueKind::StringObjectOr: {
         // It is a requirement that the or'd bits in the left argument are
         // initialized with 0. Therefore the or-operation is equivalent to an
         // addition. We need an addition to generate a valid relocation.
-        llvm::Constant *rhs = emitConstantValue(IGM, BI->getArguments()[1]);
-        if (auto *TE = dyn_cast<TupleExtractInst>(BI->getArguments()[0])) {
+        auto *rhs = emitConstantValue(IGM, args[1]).claimNextConstant();
+        if (auto *TE = dyn_cast<TupleExtractInst>(args[0])) {
           // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
           // This pattern appears in UTF8 String literal construction.
           // Generate the equivalent: add(x, sub(bits - offset)
           BuiltinInst *SubtrBI = getOffsetSubtract(TE, IGM.getSILModule());
           assert(SubtrBI && "unsupported argument of StringObjectOr");
-          auto *ptr = emitConstantValue(IGM, SubtrBI->getArguments()[0]);
-          auto *offset = emitConstantValue(IGM, SubtrBI->getArguments()[1]);
+          auto subArgs = SubtrBI->getArguments();
+          auto *ptr = emitConstantValue(IGM, subArgs[0]).claimNextConstant();
+          auto *offset = emitConstantValue(IGM, subArgs[1]).claimNextConstant();
           auto *totalOffset = llvm::ConstantExpr::getSub(rhs, offset);
           return llvm::ConstantExpr::getAdd(ptr, totalOffset);
         }
-        llvm::Constant *lhs = emitConstantValue(IGM, BI->getArguments()[0]);
+        auto *lhs = emitConstantValue(IGM, args[0]).claimNextConstant();
         return llvm::ConstantExpr::getAdd(lhs, rhs);
       }
       default:
         llvm_unreachable("unsupported builtin for constant expression");
     }
   } else if (auto *VTBI = dyn_cast<ValueToBridgeObjectInst>(operand)) {
-    auto *val = emitConstantValue(IGM, VTBI->getOperand());
+    auto *val = emitConstantValue(IGM, VTBI->getOperand()).claimNextConstant();
     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());
+    return emitConstantValue(IGM, CFI->getOperand()).claimNextConstant();
 
   } 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()),
+        emitConstantValue(IGM, T2TFI->getCallee()).claimNextConstant(),
         sTy->getTypeAtIndex((unsigned)0));
 
     auto *context = llvm::ConstantExpr::getBitCast(
@@ -287,7 +378,9 @@ llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
 llvm::Constant *irgen::emitConstantObject(IRGenModule &IGM, ObjectInst *OI,
                                          StructLayout *ClassLayout) {
   auto *sTy = cast<llvm::StructType>(ClassLayout->getType());
-  SmallVector<llvm::Constant *, 32> elts(sTy->getNumElements(), nullptr);
+
+  SmallVector<Explosion, 32> elements;
+  initWithEmptyExplosions(elements, sTy->getNumElements());
 
   unsigned NumElems = OI->getAllElements().size();
   assert(NumElems == ClassLayout->getElements().size());
@@ -297,9 +390,11 @@ llvm::Constant *irgen::emitConstantObject(IRGenModule &IGM, ObjectInst *OI,
     SILValue Val = OI->getAllElements()[i];
     const ElementLayout &EL = ClassLayout->getElements()[i];
     if (!EL.isEmpty()) {
-      unsigned EltIdx = EL.getStructIndex();
-      assert(EltIdx != 0 && "the first element is the object header");
-      elts[EltIdx] = emitConstantValue(IGM, Val);
+      unsigned idx = EL.getStructIndex();
+      assert(idx != 0 && "the first element is the object header");
+      assert(elements[idx].empty() &&
+             "Unexpected constant struct field overlap");
+      elements[idx] = emitConstantValue(IGM, Val);
     }
   }
   // Construct the object header.
@@ -322,14 +417,14 @@ llvm::Constant *irgen::emitConstantObject(IRGenModule &IGM, ObjectInst *OI,
                                         /*initializer*/ nullptr, "$ss19__EmptyArrayStorageCN");
       IGM.swiftStaticArrayMetadata = var;
     }
-    elts[0] = llvm::ConstantStruct::get(ObjectHeaderTy, {
+    elements[0].add(llvm::ConstantStruct::get(ObjectHeaderTy, {
       IGM.swiftStaticArrayMetadata,
-      llvm::ConstantExpr::getPtrToInt(IGM.swiftImmortalRefCount, IGM.IntPtrTy)});
+      llvm::ConstantExpr::getPtrToInt(IGM.swiftImmortalRefCount, IGM.IntPtrTy)}));
   } else {
-    elts[0] = llvm::Constant::getNullValue(ObjectHeaderTy);
+    elements[0].add(llvm::Constant::getNullValue(ObjectHeaderTy));
   }
-  insertPadding(elts, sTy);
-  return llvm::ConstantStruct::get(sTy, elts);
+  insertPadding(elements, sTy);
+  return createStructFromExplosion(elements, sTy);
 }
 
 void ConstantAggregateBuilderBase::addUniqueHash(StringRef data) {

lib/IRGen/GenConstant.h

@@ -38,7 +38,8 @@ llvm::Constant *emitAddrOfConstantString(IRGenModule &IGM,
                                          StringLiteralInst *SLI);
 
 /// Construct a constant from a SILValue containing constant values.
-llvm::Constant *emitConstantValue(IRGenModule &IGM, SILValue value);
+Explosion emitConstantValue(IRGenModule &IGM, SILValue value,
+                            bool flatten = false);
 
 /// Construct an object (with a HeapObject header) from an ObjectInst
 /// containing constant values.