Fix Enums with multiple payloads of < 32bit and empty payloads.

This used to crash because the code storing empty payload enum tag values would
use the bit width of the tag (32 bit) as the minimum unit to store to the
payload even if the actual bits required to store the biggest tag value in the
payload was much smaller.

With payload bit-widths < 32bit we would run out of space crashing looking for
new payload to store the value to ...

Instead pass the maximum size of the bits that need storing down.

rdar://26926035

Author: aschwaighofer

lib/IRGen/EnumPayload.cpp

@@ -84,11 +84,15 @@ template<typename Fn>
 static void withValueInPayload(IRGenFunction &IGF,
                                const EnumPayload &payload,
                                llvm::Type *valueType,
+                               int numBitsUsedInValue,
                                unsigned payloadOffset,
                                Fn &&f) {
   auto &DataLayout = IGF.IGM.DataLayout;
-  int valueBitWidth = DataLayout.getTypeSizeInBits(valueType);
-  
+  int valueTypeBitWidth = DataLayout.getTypeSizeInBits(valueType);
+  int valueBitWidth =
+      numBitsUsedInValue < 0 ? valueTypeBitWidth : numBitsUsedInValue;
+  assert(numBitsUsedInValue <= valueTypeBitWidth);
+
   // Find the elements we need to touch.
   // TODO: Linear search through the payload elements is lame.
   MutableArrayRef<EnumPayload::LazyValue> payloads = payload.PayloadValues;
@@ -107,7 +111,7 @@ static void withValueInPayload(IRGenFunction &IGF,
 
       f(payloads.front(),
         payloadBitWidth, payloadValueOffset,
-        valueBitWidth, valueOffset);
+        valueTypeBitWidth, valueOffset);
 
       // If we used the entire value, we're done.
       valueOffset += valueChunkWidth;
@@ -121,8 +125,9 @@ static void withValueInPayload(IRGenFunction &IGF,
 }
 
 void EnumPayload::insertValue(IRGenFunction &IGF, llvm::Value *value,
-                              unsigned payloadOffset) {
-  withValueInPayload(IGF, *this, value->getType(), payloadOffset,
+                              unsigned payloadOffset,
+                              int numBitsUsedInValue) {
+  withValueInPayload(IGF, *this, value->getType(), numBitsUsedInValue, payloadOffset,
     [&](LazyValue &payloadValue,
         unsigned payloadBitWidth,
         unsigned payloadValueOffset,
@@ -182,7 +187,7 @@ void EnumPayload::insertValue(IRGenFunction &IGF, llvm::Value *value,
 llvm::Value *EnumPayload::extractValue(IRGenFunction &IGF, llvm::Type *type,
                                        unsigned payloadOffset) const {
   llvm::Value *result = nullptr;
-  withValueInPayload(IGF, *this, type, payloadOffset,
+  withValueInPayload(IGF, *this, type, -1, payloadOffset,
     [&](LazyValue &payloadValue,
         unsigned payloadBitWidth,
         unsigned payloadValueOffset,

lib/IRGen/EnumPayload.h

@@ -117,8 +117,12 @@ class EnumPayload {
   /// Insert a value into the enum payload.
   ///
   /// The current payload value at the given offset is assumed to be zero.
+  /// 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,
-                   llvm::Value *value, unsigned bitOffset);
+                   llvm::Value *value, unsigned bitOffset,
+                   int numBitsUsedInValue = -1);
 
   /// Extract a value from the enum payload.
   llvm::Value *extractValue(IRGenFunction &IGF,

lib/IRGen/GenEnum.cpp

@@ -3570,7 +3570,10 @@ namespace {
       } else if (CommonSpareBits.size() > 0) {
         // Otherwise the payload is just the index.
         payload = EnumPayload::zero(IGM, PayloadSchema);
-        payload.insertValue(IGF, tagIndex, 0);
+        // We know we won't use more than numCaseBits from tagIndex's value:
+        // We made sure of this in the logic above.
+        payload.insertValue(IGF, tagIndex, 0,
+                            numCaseBits >= 32 ? -1 : numCaseBits);
       }
 
       // If the tag bits do not fit in the spare bits, the remaining tag bits

test/IRGen/enum.sil

@@ -97,6 +97,8 @@ import Swift
 
 // CHECK: [[DYNAMIC_SINGLETON:%O4enum16DynamicSingleton.*]] = type <{}>
 
+// CHECK: %O4enum40MultiPayloadLessThan32BitsWithEmptyCases = type <{ [1 x i8], [1 x i8] }>
+
 // -- Dynamic metadata template carries a value witness table pattern
 //    we fill in on instantiation.
 //    The witness table pattern includes extra inhabitant witness
@@ -2628,3 +2630,51 @@ bb4:
 // CHECK-64:         %5 = or i128 %2, %4
 // --                             0x1__0000_0000_0000_0000
 // CHECK-64:         %6 = or i128 %5, 18446744073709551616
+
+// CHECK-LABEL: define linkonce_odr hidden i32 @_TwugO4enum40MultiPayloadLessThan32BitsWithEmptyCases(%swift.opaque* %value
+// CHECK:  [[VAL00:%.*]] = bitcast %swift.opaque* %value to %O4enum40MultiPayloadLessThan32BitsWithEmptyCases*
+// CHECK:  [[VAL01:%.*]] = bitcast %O4enum40MultiPayloadLessThan32BitsWithEmptyCases* [[VAL00]] to i8*
+// CHECK:  [[VAL02:%.*]] = load {{.*}} [[VAL01]]
+// CHECK:  [[VAL03:%.*]] = getelementptr inbounds {{.*}} [[VAL00]], i32 0, i32 1
+// CHECK:  [[VAL04:%.*]] = bitcast {{.*}} [[VAL03]] to i2*
+// CHECK:  [[VAL05:%.*]] = load {{.*}} [[VAL04]]
+// CHECK:  [[VAL06:%.*]] = zext i2 [[VAL05]] to i32
+// CHECK:  [[VAL07:%.*]] = sub i32 [[VAL06]], 2
+// CHECK:  [[VAL08:%.*]] = zext i8 [[VAL02]] to i32
+// CHECK:  [[VAL09:%.*]] = and i32 [[VAL08]], 255
+// CHECK:  [[VAL10:%.*]] = icmp sge i32 [[VAL07]], 0
+// CHECK:  [[VAL11:%.*]] = select i1 [[VAL10]], i32 [[VAL09]], i32 [[VAL07]]
+// CHECK:  ret i32 [[VAL11]]
+
+// CHECK-LABEL: define linkonce_odr hidden void @_TwuiO4enum40MultiPayloadLessThan32BitsWithEmptyCases(%swift.opaque* %value, i32 %tag
+// CHECK: entry:
+// CHECK:  [[VAL00:%.*]] = bitcast %swift.opaque* %value
+// CHECK:  [[VAL01:%.*]] = icmp sge i32 %tag, 0
+// CHECK:  br i1 [[VAL01]], label %[[TLABEL:.*]], label %[[FLABEL:.*]]
+
+// CHECK: <label>:[[TLABEL]]
+// CHECK:  [[VAL03:%.*]] = trunc i32 %tag to i8
+// CHECK:  [[VAL04:%.*]] = bitcast %O4enum40MultiPayloadLessThan32BitsWithEmptyCases* [[VAL00]] to i8*
+// CHECK:  store i8 [[VAL03]], i8* [[VAL04]]
+// CHECK:  [[VAL05:%.*]] = getelementptr inbounds {{.*}} [[VAL00]], i32 0, i32 1
+// CHECK:  [[VAL06:%.*]] = bitcast [1 x i8]* [[VAL05]] to i2*
+// CHECK:  store i2 -2, i2* [[VAL06]]
+// CHECK:  br label %[[RLABEL:.*]]
+
+// CHECK: <label>:[[FLABEL]]
+// CHECK:  [[VAL08:%.*]] = add i32 %tag, 2
+// CHECK:  [[VAL09:%.*]] = trunc i32 [[VAL08]] to i2
+// CHECK:  [[VAL10:%.*]] = getelementptr inbounds {{.*}} [[VAL00]], i32 0, i32 1
+// CHECK:  [[VAL11:%.*]] = bitcast [1 x i8]* [[VAL10]] to i2*
+// CHECK:  store i2 [[VAL09]], i2* [[VAL11]]
+// CHECK:  br label %[[RLABEL]]
+
+// CHECK: <label>:[[RLABEL]]
+// CHECK:  ret void
+
+enum MultiPayloadLessThan32BitsWithEmptyCases {
+  case A
+  case B
+  case C(Builtin.Int8)
+  case D(Builtin.Int8)
+}