IRGen: change a few enum utility functions to be able to create enums in static initializers

Instead of passing `IRGenFunction`, pass the `IRGenModule` and the `IRBuilder`.
This makes enum creation not dependent on the presence of a function.

NFC, just refactoring.

Author: eeckstein

lib/IRGen/EnumPayload.cpp

@@ -120,17 +120,18 @@ static APInt createElementMask(const llvm::DataLayout &DL,
   return mask;
 }
 
-void EnumPayload::insertValue(IRGenFunction &IGF, llvm::Value *value,
+void EnumPayload::insertValue(IRGenModule &IGM,
+                              IRBuilder &builder, llvm::Value *value,
                               unsigned payloadOffset) {
-  auto &DL = IGF.IGM.DataLayout;
+  auto &DL = IGM.DataLayout;
 
   // Create a mask for the value we are going to insert.
   auto type = value->getType();
   auto payloadSize = getAllocSizeInBits(DL);
   auto mask = createElementMask(DL, type, payloadOffset, payloadSize);
 
   // Scatter the value into the payload.
-  emitScatterBits(IGF, mask, value);
+  emitScatterBits(IGM, builder, mask, value);
 }
 
 llvm::Value *EnumPayload::extractValue(IRGenFunction &IGF, llvm::Type *type,
@@ -175,13 +176,14 @@ void EnumPayload::explode(IRGenModule &IGM, Explosion &out) const {
   }
 }
 
-void EnumPayload::packIntoEnumPayload(IRGenFunction &IGF,
+void EnumPayload::packIntoEnumPayload(IRGenModule &IGM,
+                                      IRBuilder &builder,
                                       EnumPayload &outerPayload,
                                       unsigned bitOffset) const {
-  auto &DL = IGF.IGM.DataLayout;
+  auto &DL = IGM.DataLayout;
   for (auto &value : PayloadValues) {
     auto v = forcePayloadValue(value);
-    outerPayload.insertValue(IGF, v, bitOffset);
+    outerPayload.insertValue(IGM, builder, v, bitOffset);
     bitOffset += DL.getTypeSizeInBits(v->getType());
   }
 }
@@ -419,12 +421,13 @@ EnumPayload::emitApplyAndMask(IRGenFunction &IGF, const APInt &mask) {
 }
 
 void
-EnumPayload::emitApplyOrMask(IRGenFunction &IGF, const APInt &mask) {
+EnumPayload::emitApplyOrMask(IRGenModule &IGM,
+                             IRBuilder &builder, const APInt &mask) {
   // Early exit if the mask has no effect.
   if (mask == 0)
     return;
 
-  auto &DL = IGF.IGM.DataLayout;
+  auto &DL = IGM.DataLayout;
   auto maskReader = BitPatternReader(mask, DL.isLittleEndian());
 
   for (auto &pv : PayloadValues) {
@@ -438,21 +441,21 @@ EnumPayload::emitApplyOrMask(IRGenFunction &IGF, const APInt &mask) {
     if (maskPiece == 0)
       continue;
 
-    auto payloadIntTy = llvm::IntegerType::get(IGF.IGM.getLLVMContext(), size);
+    auto payloadIntTy = llvm::IntegerType::get(IGM.getLLVMContext(), size);
     auto maskConstant = llvm::ConstantInt::get(payloadIntTy, maskPiece);
 
     // If the payload value is vacant, or the mask is all ones,
     // we can adopt the mask value directly.
     if (pv.is<llvm::Type *>() || maskPiece.isAllOnesValue()) {
-      pv = IGF.Builder.CreateBitOrPointerCast(maskConstant, payloadTy);
+      pv = builder.CreateBitOrPointerCast(maskConstant, payloadTy);
       continue;
     }
 
     // Otherwise, apply the mask to the existing value.
     auto v = pv.get<llvm::Value*>();
-    v = IGF.Builder.CreateBitOrPointerCast(v, payloadIntTy);
-    v = IGF.Builder.CreateOr(v, maskConstant);
-    v = IGF.Builder.CreateBitOrPointerCast(v, payloadTy);
+    v = builder.CreateBitOrPointerCast(v, payloadIntTy);
+    v = builder.CreateOr(v, maskConstant);
+    v = builder.CreateBitOrPointerCast(v, payloadTy);
     pv = v;
   }
 }
@@ -490,11 +493,11 @@ EnumPayload::emitApplyOrMask(IRGenFunction &IGF,
   }
 }
 
-void EnumPayload::emitScatterBits(IRGenFunction &IGF,
+void EnumPayload::emitScatterBits(IRGenModule &IGM,
+                                  IRBuilder &builder,
                                   const APInt &mask,
                                   llvm::Value *value) {
-  auto &DL = IGF.IGM.DataLayout;
-  auto &B = IGF.Builder;
+  auto &DL = IGM.DataLayout;
 
   unsigned valueBits = DL.getTypeSizeInBits(value->getType());
   auto totalBits = std::min(valueBits, mask.countPopulation());
@@ -519,20 +522,20 @@ void EnumPayload::emitScatterBits(IRGenFunction &IGF,
     if (DL.isBigEndian()) {
       offset = totalBits - partCount - usedBits;
     }
-    auto partValue = irgen::emitScatterBits(IGF, partMask, value, offset);
+    auto partValue = irgen::emitScatterBits(IGM, builder, partMask, value, offset);
 
     // If necessary OR with the existing value.
     if (auto existingValue = pv.dyn_cast<llvm::Value*>()) {
       if (partType != partValue->getType()) {
-        existingValue = B.CreateBitOrPointerCast(existingValue,
+        existingValue = builder.CreateBitOrPointerCast(existingValue,
                                                  partValue->getType());
       }
-      partValue = B.CreateOr(partValue, existingValue);
+      partValue = builder.CreateOr(partValue, existingValue);
     }
 
     // Convert the integer result to the target type.
     if (partType != partValue->getType()) {
-      partValue = B.CreateBitOrPointerCast(partValue, partType);
+      partValue = builder.CreateBitOrPointerCast(partValue, partType);
     }
 
     // Update this payload element.

lib/IRGen/EnumPayload.h

@@ -104,7 +104,8 @@ class EnumPayload {
   /// If \p numBitsUsedInValue is non-negative denotes the actual number of bits
   /// that need storing in \p value otherwise the full bit-width of \p value
   /// will be stored.
-  void insertValue(IRGenFunction &IGF,
+  void insertValue(IRGenModule &IGM,
+                   IRBuilder &builder,
                    llvm::Value *value, unsigned bitOffset);
 
   /// Extract a value from the enum payload.
@@ -120,7 +121,8 @@ class EnumPayload {
   void explode(IRGenModule &IGM, Explosion &out) const;
 
   /// Pack into another enum payload.
-  void packIntoEnumPayload(IRGenFunction &IGF,
+  void packIntoEnumPayload(IRGenModule &IGM,
+                           IRBuilder &builder,
                            EnumPayload &dest,
                            unsigned bitOffset) const;
 
@@ -153,15 +155,17 @@ class EnumPayload {
   void emitApplyAndMask(IRGenFunction &IGF, const APInt &mask);
 
   /// Apply an OR mask to the payload.
-  void emitApplyOrMask(IRGenFunction &IGF, const APInt &mask);
+  void emitApplyOrMask(IRGenModule &IGM,
+                       IRBuilder &builder, const APInt &mask);
 
   /// Apply an OR mask to the payload.
   void emitApplyOrMask(IRGenFunction &IGF, EnumPayload mask);
 
   /// Scatter the bits in value to the bit positions indicated by the
   /// mask. The new bits are added using OR, so an emitApplyAndMask
   /// call should be used first if existing bits need to be cleared.
-  void emitScatterBits(IRGenFunction &IGF,
+  void emitScatterBits(IRGenModule &IGM,
+                       IRBuilder &builder,
                        const APInt &mask,
                        llvm::Value *value);
 

lib/IRGen/GenCall.cpp

@@ -3860,7 +3860,7 @@ bool irgen::addNativeArgument(IRGenFunction &IGF,
     // Pass the argument explosion directly, mapping into the native swift
     // calling convention.
     Explosion nonNativeParam;
-    ti.reexplode(IGF, in, nonNativeParam);
+    ti.reexplode(in, nonNativeParam);
     Explosion nativeParam = nativeSchema.mapIntoNative(
         IGF.IGM, IGF, nonNativeParam, paramType, isOutlined);
     nativeParam.transferInto(out, nativeParam.size());