[IRGen] Use generic value witness functions for prespecialized types.

Previously, specialized value witness functions were emitted and used in
the prespecialized value witness table corresponding to and pointed to
by the prespecialized metadata for a generic type whose metadata was
prespecialized.  That incurs a codesize cost: specialized value witness
functions had to be emitted.  Here, the generic value witness functions
are used instead.

The change is not entirely trivial, though.  We can't simply emit all
the witnesses for the unbound generic type (indeed if that were possible
there would be no need to emit a separate VWT).  There are two reasons:
(1) the non-function fields (size, stride, flags, extra inhabitant
count) need to be those for the specialized generic type, (2) in the
case of multi-payload enums, the getEnumTagSinglePayload and
storeEnumTagSinglePayload witnesses cannot be those emitted for the
unspecialized generic type--instead they need to be
swift_getMultiPayloadEnumTagSinglePayload and
swift_storeMultiPayloadEnumTagSinglePayload respectively.

Author: nate-chandler

lib/IRGen/GenValueWitness.cpp

@@ -41,6 +41,7 @@
 #include "IRGenDebugInfo.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
+#include "MetadataLayout.h"
 #include "StructLayout.h"
 #include "TypeInfo.h"
 
@@ -815,15 +816,72 @@ static llvm::Constant *getMemCpyFunction(IRGenModule &IGM,
   });
 }
 
+namespace {
+struct BoundGenericTypeCharacteristics {
+  SILType concreteType;
+  const TypeInfo *TI;
+  FixedPacking packing;
+};
+
+ValueWitnessFlags getValueWitnessFlags(const TypeInfo *TI, SILType concreteType,
+                                       FixedPacking packing) {
+  ValueWitnessFlags flags;
+
+  // If we locally know that the type has fixed layout, we can emit
+  // meaningful flags for it.
+  if (auto *fixedTI = dyn_cast<FixedTypeInfo>(TI)) {
+    assert(packing == FixedPacking::OffsetZero ||
+           packing == FixedPacking::Allocate);
+    bool isInline = packing == FixedPacking::OffsetZero;
+    bool isBitwiseTakable =
+        fixedTI->isBitwiseTakable(ResilienceExpansion::Maximal);
+    assert(isBitwiseTakable || !isInline);
+    flags = flags.withAlignment(fixedTI->getFixedAlignment().getValue())
+                .withPOD(fixedTI->isPOD(ResilienceExpansion::Maximal))
+                .withInlineStorage(isInline)
+                .withBitwiseTakable(isBitwiseTakable);
+  } else {
+    flags = flags.withIncomplete(true);
+  }
+
+  if (concreteType.getEnumOrBoundGenericEnum())
+    flags = flags.withEnumWitnesses(true);
+
+  return flags;
+}
+
+unsigned getExtraInhabitantCount(const TypeInfo *TI, IRGenModule &IGM) {
+  unsigned value = 0;
+  if (auto *fixedTI = dyn_cast<FixedTypeInfo>(TI)) {
+    value = fixedTI->getFixedExtraInhabitantCount(IGM);
+  }
+  return value;
+}
+
+void addSize(ConstantStructBuilder &B, const TypeInfo *TI, IRGenModule &IGM) {
+  if (auto staticSize = TI->getStaticSize(IGM))
+    return B.add(staticSize);
+  // Just fill in 0 here if the type can't be statically laid out.
+  return B.addSize(Size(0));
+}
+
+void addStride(ConstantStructBuilder &B, const TypeInfo *TI, IRGenModule &IGM) {
+  if (auto value = TI->getStaticStride(IGM))
+    return B.add(value);
+
+  // Just fill in null here if the type can't be statically laid out.
+  return B.addSize(Size(0));
+}
+} // end anonymous namespace
+
 /// Find a witness to the fact that a type is a value type.
 /// Always adds an i8*.
-static void addValueWitness(IRGenModule &IGM,
-                            ConstantStructBuilder &B,
-                            ValueWitness index,
-                            FixedPacking packing,
-                            CanType abstractType,
-                            SILType concreteType,
-                            const TypeInfo &concreteTI) {
+static void addValueWitness(IRGenModule &IGM, ConstantStructBuilder &B,
+                            ValueWitness index, FixedPacking packing,
+                            CanType abstractType, SILType concreteType,
+                            const TypeInfo &concreteTI,
+                            const Optional<BoundGenericTypeCharacteristics>
+                                boundGenericCharacteristics = llvm::None) {
   auto addFunction = [&](llvm::Constant *fn) {
     fn = llvm::ConstantExpr::getBitCast(fn, IGM.Int8PtrTy);
     B.addSignedPointer(fn, IGM.getOptions().PointerAuth.ValueWitnesses, index);
@@ -880,57 +938,51 @@ static void addValueWitness(IRGenModule &IGM,
     goto standard;
 
   case ValueWitness::Size: {
-    if (auto value = concreteTI.getStaticSize(IGM))
-      return B.add(value);
-
-    // Just fill in 0 here if the type can't be statically laid out.
-    return B.addSize(Size(0));
+    if (boundGenericCharacteristics)
+      return addSize(B, boundGenericCharacteristics->TI, IGM);
+    return addSize(B, &concreteTI, IGM);
   }
 
   case ValueWitness::Flags: {
-    ValueWitnessFlags flags;
-
-    // If we locally know that the type has fixed layout, we can emit
-    // meaningful flags for it.
-    if (auto *fixedTI = dyn_cast<FixedTypeInfo>(&concreteTI)) {
-      assert(packing == FixedPacking::OffsetZero ||
-             packing == FixedPacking::Allocate);
-      bool isInline = packing == FixedPacking::OffsetZero;
-      bool isBitwiseTakable =
-          fixedTI->isBitwiseTakable(ResilienceExpansion::Maximal);
-      assert(isBitwiseTakable || !isInline);
-      flags = flags.withAlignment(fixedTI->getFixedAlignment().getValue())
-                  .withPOD(fixedTI->isPOD(ResilienceExpansion::Maximal))
-                  .withInlineStorage(isInline)
-                  .withBitwiseTakable(isBitwiseTakable);
-    } else {
-      flags = flags.withIncomplete(true);
-    }
-
-    if (concreteType.getEnumOrBoundGenericEnum())
-      flags = flags.withEnumWitnesses(true);
-
-    return B.addInt32(flags.getOpaqueValue());
+    if (boundGenericCharacteristics)
+      return B.addInt32(
+          getValueWitnessFlags(boundGenericCharacteristics->TI,
+                               boundGenericCharacteristics->concreteType,
+                               boundGenericCharacteristics->packing)
+              .getOpaqueValue());
+    return B.addInt32(getValueWitnessFlags(&concreteTI, concreteType, packing)
+                          .getOpaqueValue());
   }
 
   case ValueWitness::ExtraInhabitantCount: {
-    unsigned value = 0;
-    if (auto *fixedTI = dyn_cast<FixedTypeInfo>(&concreteTI)) {
-      value = fixedTI->getFixedExtraInhabitantCount(IGM);
-    }
-    return B.addInt32(value);
+    if (boundGenericCharacteristics)
+      return B.addInt32(
+          getExtraInhabitantCount(boundGenericCharacteristics->TI, IGM));
+    return B.addInt32(getExtraInhabitantCount(&concreteTI, IGM));
   }
 
   case ValueWitness::Stride: {
-    if (auto value = concreteTI.getStaticStride(IGM))
-      return B.add(value);
-
-    // Just fill in null here if the type can't be statically laid out.
-    return B.addSize(Size(0));
+    if (boundGenericCharacteristics)
+      return addStride(B, boundGenericCharacteristics->TI, IGM);
+    return addStride(B, &concreteTI, IGM);
   }
 
-  case ValueWitness::GetEnumTagSinglePayload:
+  case ValueWitness::GetEnumTagSinglePayload: {
+    if (boundGenericCharacteristics)
+      if (auto *enumDecl = boundGenericCharacteristics->concreteType
+                               .getEnumOrBoundGenericEnum())
+        if (IGM.getMetadataLayout(enumDecl).hasPayloadSizeOffset())
+          return B.add(llvm::ConstantExpr::getBitCast(
+              IGM.getGetMultiPayloadEnumTagSinglePayloadFn(), IGM.Int8PtrTy));
+    goto standard;
+  }
   case ValueWitness::StoreEnumTagSinglePayload: {
+    if (boundGenericCharacteristics)
+      if (auto *enumDecl = boundGenericCharacteristics->concreteType
+                               .getEnumOrBoundGenericEnum())
+        if (IGM.getMetadataLayout(enumDecl).hasPayloadSizeOffset())
+          return B.add(llvm::ConstantExpr::getBitCast(
+              IGM.getStoreMultiPayloadEnumTagSinglePayloadFn(), IGM.Int8PtrTy));
     goto standard;
   }
 
@@ -949,7 +1001,7 @@ static void addValueWitness(IRGenModule &IGM,
     buildValueWitnessFunction(IGM, fn, index, packing, abstractType,
                               concreteType, concreteTI);
   addFunction(fn);
-}
+ }
 
 static bool shouldAddEnumWitnesses(CanType abstractType) {
   // Needs to handle UnboundGenericType.
@@ -964,22 +1016,21 @@ static llvm::StructType *getValueWitnessTableType(IRGenModule &IGM,
 }
 
 /// Collect the value witnesses for a particular type.
-static void addValueWitnesses(IRGenModule &IGM,
-                              ConstantStructBuilder &B,
-                              FixedPacking packing,
-                              CanType abstractType,
-                              SILType concreteType,
-                              const TypeInfo &concreteTI) {
+static void addValueWitnesses(IRGenModule &IGM, ConstantStructBuilder &B,
+                              FixedPacking packing, CanType abstractType,
+                              SILType concreteType, const TypeInfo &concreteTI,
+                              const Optional<BoundGenericTypeCharacteristics>
+                                  boundGenericCharacteristics = llvm::None) {
   for (unsigned i = 0; i != NumRequiredValueWitnesses; ++i) {
-    addValueWitness(IGM, B, ValueWitness(i), packing,
-                    abstractType, concreteType, concreteTI);
+    addValueWitness(IGM, B, ValueWitness(i), packing, abstractType,
+                    concreteType, concreteTI, boundGenericCharacteristics);
   }
   if (shouldAddEnumWitnesses(abstractType)) {
     for (auto i = unsigned(ValueWitness::First_EnumValueWitness);
          i <= unsigned(ValueWitness::Last_EnumValueWitness);
          ++i) {
-      addValueWitness(IGM, B, ValueWitness(i), packing,
-                      abstractType, concreteType, concreteTI);
+      addValueWitness(IGM, B, ValueWitness(i), packing, abstractType,
+                      concreteType, concreteTI, boundGenericCharacteristics);
     }
   }
 }
@@ -995,6 +1046,19 @@ static void addValueWitnessesForAbstractType(IRGenModule &IGM,
                                              ConstantStructBuilder &B,
                                              CanType abstractType,
                                              bool &canBeConstant) {
+  Optional<BoundGenericTypeCharacteristics> boundGenericCharacteristics;
+  if (auto boundGenericType = dyn_cast<BoundGenericType>(abstractType)) {
+    CanType concreteFormalType = getFormalTypeInContext(abstractType);
+
+    auto concreteLoweredType = IGM.getLoweredType(concreteFormalType);
+    const auto *boundConcreteTI = &IGM.getTypeInfo(concreteLoweredType);
+    auto packing = boundConcreteTI->getFixedPacking(IGM);
+    boundGenericCharacteristics = {concreteLoweredType, boundConcreteTI,
+                                   packing};
+
+    abstractType =
+        boundGenericType->getDecl()->getDeclaredType()->getCanonicalType();
+  }
   CanType concreteFormalType = getFormalTypeInContext(abstractType);
 
   auto concreteLoweredType = IGM.getLoweredType(concreteFormalType);
@@ -1003,10 +1067,12 @@ static void addValueWitnessesForAbstractType(IRGenModule &IGM,
 
   // For now, assume that we never have any interest in dynamically
   // changing the value witnesses for something that's fixed-layout.
-  canBeConstant = concreteTI.isFixedSize();
+  canBeConstant = boundGenericCharacteristics
+                      ? boundGenericCharacteristics->TI->isFixedSize()
+                      : concreteTI.isFixedSize();
 
-  addValueWitnesses(IGM, B, packing, abstractType,
-                    concreteLoweredType, concreteTI);
+  addValueWitnesses(IGM, B, packing, abstractType, concreteLoweredType,
+                    concreteTI, boundGenericCharacteristics);
 }
 
 static constexpr uint64_t sizeAndAlignment(Size size, Alignment alignment) {

test/IRGen/prespecialized-metadata/enum-inmodule-1argument-1distinct_use.swift

@@ -6,21 +6,21 @@
 // UNSUPPORTED: CPU=armv7s && OS=ios
 
 // CHECK: @"$s4main5ValueOySiGWV" = linkonce_odr hidden constant %swift.enum_vwtable { 
-// CHECK-SAME:   i8* bitcast ({{(%swift.opaque\* \(\[[0-9]+ x i8\]\*, \[[0-9]+ x i8\]\*, %swift.type\*\)\* @"\$[a-zA-Z0-9_]+" to i8\*|[^@]+@__swift_memcpy[0-9]+_[0-9]+[^\)]* to i8\*)}}), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_noop_void_return{{[^\)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOySiGwet{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOySiGwst{{[^)]+}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwCP{{[^\)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwxx{{[^)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwcp{{[^)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwca{{[^)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwtk{{[^)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwta{{[^)]*}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwet{{[^)]+}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwst{{[^)]+}} to i8*), 
 // CHECK-SAME:   [[INT]] [[ALIGNMENT]], 
 // CHECK-SAME:   [[INT]] [[ALIGNMENT]], 
 // CHECK-SAME:   i32 {{[0-9]+}}, 
 // CHECK-SAME:   i32 0, 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOySiGwug{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOySiGwup{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOySiGwui{{[^)]+}} to i8*) 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwug{{[^)]+}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwup{{[^)]+}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwui{{[^)]+}} to i8*) 
 // CHECK-SAME: }, align [[ALIGNMENT]]
 // CHECK: @"$s4main5ValueOySiGMf" = linkonce_odr hidden constant <{ 
 // CHECK-SAME:   i8**, 

test/IRGen/prespecialized-metadata/enum-inmodule-2argument-1distinct_use.swift

@@ -5,39 +5,39 @@
 // UNSUPPORTED: CPU=armv7 && OS=ios
 // UNSUPPORTED: CPU=armv7s && OS=ios
 
-// CHECK: @"$s4main5ValueOyS2iGWV" = linkonce_odr hidden constant %swift.enum_vwtable { 
-// CHECK-SAME:   i8* bitcast ({{(%swift.opaque\* \(\[[0-9]+ x i8\]\*, \[[0-9]+ x i8\]\*, %swift.type\*\)\* @"\$[a-zA-Z0-9_]+" to i8\*|[^@]+@__swift_memcpy[0-9]+_[0-9]+[^\)]* to i8\*)}}), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_noop_void_return{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS2iGwet{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS2iGwst{{[^)]+}} to i8*), 
-// CHECK-SAME:   [[INT]] {{[0-9]+}}, 
-// CHECK-SAME:   [[INT]] {{[0-9]+}}, 
-// CHECK-SAME:   i32 {{[0-9]+}}, 
-// CHECK-SAME:   i32 {{[0-9]+}}, 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS2iGwug{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS2iGwup{{[^)]+}} to i8*), 
-// CHECK-SAME    i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS2iGwui{{[^)]+}} to i8*) 
+// CHECK: @"$s4main5ValueOyS2iGWV" = linkonce_odr hidden constant %swift.enum_vwtable {
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwCP{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwxx{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwcp{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwca{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwtk{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwta{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@swift_getMultiPayloadEnumTagSinglePayload{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@swift_storeMultiPayloadEnumTagSinglePayload{{[^)]*}} to i8*),
+// CHECK-SAME:   [[INT]] {{[0-9]+}},
+// CHECK-SAME:   [[INT]] {{[0-9]+}},
+// CHECK-SAME:   i32 {{[0-9]+}},
+// CHECK-SAME:   i32 {{[0-9]+}},
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwug{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwup{{[^)]+}} to i8*),
+// CHECK-SAME    i8* bitcast ({{[^@]+}}@"$s4main5ValueOwui{{[^)]+}} to i8*)
 // CHECK-SAME: }, align [[ALIGNMENT]]
-// CHECK: @"$s4main5ValueOyS2iGMf" = linkonce_odr hidden constant <{ 
-// CHECK-SAME:   i8**, 
-// CHECK-SAME:   [[INT]], 
-// CHECK-SAME:   %swift.type_descriptor*, 
-// CHECK-SAME:   %swift.type*, 
-// CHECK-SAME:   i64 
-// CHECK-SAME:   }> <{ 
-// CHECK-SAME:   i8** getelementptr inbounds (%swift.enum_vwtable, %swift.enum_vwtable* @"$s4main5ValueOyS2iGWV", i32 0, i32 0), 
-// CHECK-SAME:   [[INT]] 513, 
+// CHECK: @"$s4main5ValueOyS2iGMf" = linkonce_odr hidden constant <{
+// CHECK-SAME:   i8**,
+// CHECK-SAME:   [[INT]],
+// CHECK-SAME:   %swift.type_descriptor*,
+// CHECK-SAME:   %swift.type*,
+// CHECK-SAME:   i64
+// CHECK-SAME:   }> <{
+// CHECK-SAME:   i8** getelementptr inbounds (%swift.enum_vwtable, %swift.enum_vwtable* @"$s4main5ValueOyS2iGWV", i32 0, i32 0),
+// CHECK-SAME:   [[INT]] 513,
 // CHECK-SAME:   %swift.type_descriptor* bitcast (
 // CHECK-SAME:     {{.*}}$s4main5ValueOMn{{.*}} to %swift.type_descriptor*
-// CHECK-SAME:   ), 
-// CHECK-SAME:   %swift.type* @"$sSiN", 
-// CHECK-SAME:   %swift.type* @"$sSiN", 
-// CHECK-SAME:   [[INT]] {{16|8}}, 
-// CHECK-SAME:   i64 3 
+// CHECK-SAME:   ),
+// CHECK-SAME:   %swift.type* @"$sSiN",
+// CHECK-SAME:   %swift.type* @"$sSiN",
+// CHECK-SAME:   [[INT]] {{16|8}},
+// CHECK-SAME:   i64 3
 // CHECK-SAME: }>, align [[ALIGNMENT]]
 enum Value<First, Second> {
   case first(First)

test/IRGen/prespecialized-metadata/enum-inmodule-3argument-1distinct_use.swift

@@ -5,22 +5,22 @@
 // UNSUPPORTED: CPU=armv7 && OS=ios
 // UNSUPPORTED: CPU=armv7s && OS=ios
 
-// CHECK: @"$s4main5ValueOyS3iGWV" = linkonce_odr hidden constant %swift.enum_vwtable { 
-// CHECK-SAME:   i8* bitcast ({{([^@]+@"\$s4main5ValueOyS3iGwCP[^\)]+ to i8\*|[^@]+@__swift_memcpy[0-9]+_[0-9]+[^\)]+ to i8\*)}}), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_noop_void_return{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@__swift_memcpy{{[0-9]+}}_{{[0-9]+}}{{[^)]*}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS3iGwet{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS3iGwst{{[^)]+}} to i8*), 
+// CHECK: @"$s4main5ValueOyS3iGWV" = linkonce_odr hidden constant %swift.enum_vwtable {
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwCP{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwxx{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwcp{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwca{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwtk{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwta{{[^)]+}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@swift_getMultiPayloadEnumTagSinglePayload{{[^)]*}} to i8*),
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@swift_storeMultiPayloadEnumTagSinglePayload{{[^)]*}} to i8*),
 // CHECK-SAME:   [[INT]] {{[0-9]+}}, 
 // CHECK-SAME:   [[INT]] {{[0-9]+}}, 
 // CHECK-SAME:   i32 {{[0-9]+}}, 
 // CHECK-SAME:   i32 {{[0-9]+}}, 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS3iGwug{{[^)]+}} to i8*), 
-// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS3iGwup{{[^)]+}} to i8*), 
-// CHECK-SAME    i8* bitcast ({{[^@]+}}@"$s4main5ValueOyS3iGwui{{[^)]+}} to i8*) 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwug{{[^)]+}} to i8*), 
+// CHECK-SAME:   i8* bitcast ({{[^@]+}}@"$s4main5ValueOwup{{[^)]+}} to i8*),
+// CHECK-SAME    i8* bitcast ({{[^@]+}}@"$s4main5ValueOwui{{[^)]+}} to i8*),
 // CHECK-SAME: }, align [[ALIGNMENT]]
 // CHECK: @"$s4main5ValueOyS3iGMf" = linkonce_odr hidden constant <{ 
 // CHECK-SAME:   i8**,