Merge pull request #3416 from aschwaighofer/fix_multismallpayloadwithemptycases

Author: swift-ci

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)
+}