[IRGen] Generate layout strings for subset of enums (#63930)

drexin · web-flow · commit a0e1810f627a · 2023-02-27T07:33:34.000-08:00
rdar://105959425
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -1591,14 +1591,16 @@ namespace {
     
     Size PayloadSizeOffset;
     const EnumImplStrategy &Strategy;
-    
+    bool hasLayoutString;
+
   public:
     EnumContextDescriptorBuilder(IRGenModule &IGM, EnumDecl *Type,
-                                 RequireMetadata_t requireMetadata)
-      : super(IGM, Type, requireMetadata),
-        Strategy(getEnumImplStrategy(IGM,
-                     getType()->getDeclaredTypeInContext()->getCanonicalType()))
-    {
+                                 RequireMetadata_t requireMetadata,
+                                 bool hasLayoutString)
+        : super(IGM, Type, requireMetadata),
+          Strategy(getEnumImplStrategy(
+              IGM, getType()->getDeclaredTypeInContext()->getCanonicalType())),
+          hasLayoutString(hasLayoutString) {
       auto &layout = IGM.getMetadataLayout(getType());
       if (layout.hasPayloadSizeOffset())
         PayloadSizeOffset = layout.getPayloadSizeOffset().getStatic();
@@ -1635,6 +1637,8 @@ namespace {
       TypeContextDescriptorFlags flags;
 
       setCommonFlags(flags);
+      flags.setHasLayoutString(hasLayoutString);
+
       return flags.getOpaqueValue();
     }
 
@@ -2567,7 +2571,9 @@ void irgen::emitLazyTypeContextDescriptor(IRGenModule &IGM,
     StructContextDescriptorBuilder(IGM, sd, requireMetadata,
                                    /*hasLayoutString*/ false).emit();
   } else if (auto ed = dyn_cast<EnumDecl>(type)) {
-    EnumContextDescriptorBuilder(IGM, ed, requireMetadata).emit();
+    EnumContextDescriptorBuilder(IGM, ed, requireMetadata,
+                                 /*hasLayoutString*/ false)
+        .emit();
   } else if (auto cd = dyn_cast<ClassDecl>(type)) {
     ClassContextDescriptorBuilder(IGM, cd, requireMetadata).emit();
   } else {
@@ -5277,8 +5283,9 @@ namespace {
     }
 
     llvm::Constant *emitNominalTypeDescriptor() {
-      auto descriptor =
-        EnumContextDescriptorBuilder(IGM, Target, RequireMetadata).emit();
+      auto descriptor = EnumContextDescriptorBuilder(
+                            IGM, Target, RequireMetadata, !!getLayoutString())
+                            .emit();
       return descriptor;
     }
 
@@ -5471,7 +5478,9 @@ namespace {
     }
 
     llvm::Constant *emitNominalTypeDescriptor() {
-      return EnumContextDescriptorBuilder(IGM, Target, RequireMetadata).emit();
+      return EnumContextDescriptorBuilder(IGM, Target, RequireMetadata,
+                                          /*hasLayoutString*/ false)
+          .emit();
     }
 
     GenericMetadataPatternFlags getPatternFlags() {
diff --git a/lib/IRGen/TypeLayout.cpp b/lib/IRGen/TypeLayout.cpp
@@ -2181,51 +2181,63 @@ llvm::Value *EnumTypeLayoutEntry::isBitwiseTakable(IRGenFunction &IGF) const {
 llvm::Constant *
 EnumTypeLayoutEntry::layoutString(IRGenModule &IGM,
                                   GenericSignature genericSig) const {
-  return nullptr;
-  // LayoutStringBuilder B{};
+  switch (copyDestroyKind(IGM)) {
+  case CopyDestroyStrategy::POD:
+  case CopyDestroyStrategy::Normal: {
+    return nullptr;
+  }
+  case CopyDestroyStrategy::ForwardToPayload:
+  case CopyDestroyStrategy::NullableRefcounted: {
+    LayoutStringBuilder B{};
 
-  // if (containsArchetypeField() ||
-  //     containsResilientField() ||
-  //     isMultiPayloadEnum() ||
-  //     !refCountString(IGM, B)) {
-  //   return nullptr;
-  // }
+    if (containsArchetypeField() || containsResilientField() ||
+        isMultiPayloadEnum() || !refCountString(IGM, B, genericSig)) {
+      return nullptr;
+    }
 
-  // ConstantInitBuilder IB(IGM);
-  // auto SB = IB.beginStruct();
-  // SB.setPacked(true);
+    ConstantInitBuilder IB(IGM);
+    auto SB = IB.beginStruct();
+    SB.setPacked(true);
 
-  // B.result(IGM, SB);
+    B.result(IGM, SB);
+
+    IRGenMangler mangler;
+    std::string symbolName =
+        mangler.mangleSymbolNameForMangledMetadataAccessorString(
+            "type_layout_string", genericSig.getCanonicalSignature(),
+            ty.getASTType()->mapTypeOutOfContext()->getCanonicalType());
 
-  // return SB.finishAndCreateGlobal("", IGM.getPointerAlignment(),
-  //                                 /*constant*/ true);
+    return SB.finishAndCreateGlobal(symbolName, IGM.getPointerAlignment(),
+                                    /*constant*/ true);
+  }
+  }
 }
 
 bool EnumTypeLayoutEntry::refCountString(IRGenModule &IGM,
                                          LayoutStringBuilder &B,
                                          GenericSignature genericSig) const {
-  // switch (copyDestroyKind(IGM)) {
-  // case CopyDestroyStrategy::POD: {
-  //   auto size = fixedSize(IGM);
-  //   assert(size && "POD should not have dynamic size");
-  //   B.addSkip(size->getValue());
-  //   return true;
-  // }
-  // case CopyDestroyStrategy::NullableRefcounted:
-  // case CopyDestroyStrategy::ForwardToPayload:
-  //   return cases[0]->refCountString(IGM, B, genericSig);
-  // case CopyDestroyStrategy::Normal:
-    auto *accessor = createMetatypeAccessorFunction(IGM, ty, genericSig);
+  switch (copyDestroyKind(IGM)) {
+  case CopyDestroyStrategy::POD: {
+    auto size = fixedSize(IGM);
+    assert(size && "POD should not have dynamic size");
+    B.addSkip(size->getValue());
+    return true;
+  }
+  case CopyDestroyStrategy::NullableRefcounted:
+  case CopyDestroyStrategy::ForwardToPayload:
+    return cases[0]->refCountString(IGM, B, genericSig);
+  case CopyDestroyStrategy::Normal: {
     if (genericSig || !isFixedSize(IGM)) {
-      B.addResilientRefCount(accessor);
+      //      B.addResilientRefCount(accessor);
       return false;
-    } else {
-      B.addFixedEnumRefCount(accessor);
-      B.addSkip(fixedSize(IGM)->getValue());
     }
 
+    auto *accessor = createMetatypeAccessorFunction(IGM, ty, genericSig);
+    B.addFixedEnumRefCount(accessor);
+    B.addSkip(fixedSize(IGM)->getValue());
     return true;
-  // }
+  }
+  }
 }
 
 void EnumTypeLayoutEntry::computeProperties() {
@@ -2245,7 +2257,8 @@ EnumTypeLayoutEntry::copyDestroyKind(IRGenModule &IGM) const {
     return NullableRefcounted;
   } else {
     unsigned numTags = numEmptyCases;
-    if (cases[0]->canValueWitnessExtraInhabitantsUpTo(IGM, numTags - 1)) {
+    if (cases.size() == 1 &&
+        cases[0]->canValueWitnessExtraInhabitantsUpTo(IGM, numTags - 1)) {
       return ForwardToPayload;
     }
     return Normal;
diff --git a/test/Interpreter/Inputs/layout_string_witnesses_types.swift b/test/Interpreter/Inputs/layout_string_witnesses_types.swift
@@ -1,3 +1,5 @@
+import Swift
+
 public class SimpleClass {
     public let x: Int
 
@@ -134,6 +136,16 @@ public struct ExistentialRefWrapper {
     }
 }
 
+public enum NullableRefEnum {
+    case nonEmpty(SimpleClass)
+    case empty
+}
+
+public enum ForwardToPayloadEnum {
+    case nonEmpty(SimpleClass, Int)
+    case empty
+}
+
 #if os(macOS)
 import Foundation
 
diff --git a/test/Interpreter/layout_string_witnesses_static.swift b/test/Interpreter/layout_string_witnesses_static.swift
@@ -1,14 +1,15 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -enable-experimental-feature LayoutStringValueWitnesses -enable-type-layout -emit-module -emit-module-path=%t/layout_string_witnesses_types.swiftmodule %S/Inputs/layout_string_witnesses_types.swift
-// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-type-layout -c -parse-as-library -o %t/layout_string_witnesses_types.o %S/Inputs/layout_string_witnesses_types.swift
+// RUN: %target-swift-frontend -enable-experimental-feature LayoutStringValueWitnesses -enable-type-layout -parse-stdlib -emit-module -emit-module-path=%t/layout_string_witnesses_types.swiftmodule %S/Inputs/layout_string_witnesses_types.swift
+// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-type-layout -Xfrontend -parse-stdlib -c -parse-as-library -o %t/layout_string_witnesses_types.o %S/Inputs/layout_string_witnesses_types.swift
 // RUN: %target-swift-frontend -enable-experimental-feature LayoutStringValueWitnesses -enable-library-evolution -emit-module -emit-module-path=%t/layout_string_witnesses_types_resilient.swiftmodule %S/Inputs/layout_string_witnesses_types_resilient.swift
 // RUN: %target-build-swift -g -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-library-evolution -c -parse-as-library -o %t/layout_string_witnesses_types_resilient.o %S/Inputs/layout_string_witnesses_types_resilient.swift
-// RUN: %target-build-swift -g -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-type-layout -module-name layout_string_witnesses_static %t/layout_string_witnesses_types.o %t/layout_string_witnesses_types_resilient.o -I %t -o %t/main %s
+// RUN: %target-build-swift -g -Xfrontend -enable-experimental-feature -Xfrontend LayoutStringValueWitnesses -Xfrontend -enable-type-layout -Xfrontend -parse-stdlib -module-name layout_string_witnesses_static %t/layout_string_witnesses_types.o %t/layout_string_witnesses_types_resilient.o -I %t -o %t/main %s
 // RUN: %target-codesign %t/main
 // RUN: %target-run %t/main | %FileCheck %s --check-prefix=CHECK -check-prefix=CHECK-%target-os
 
 // REQUIRES: executable_test
 
+import Swift
 import layout_string_witnesses_types
 import layout_string_witnesses_types_resilient
 
@@ -189,7 +190,7 @@ class ClassWithSomeProtocol: SomeProtocol {
 
 func testExistential() {
     let ptr = UnsafeMutablePointer<ExistentialWrapper>.allocate(capacity: 1)
-    
+
     do {
         let x = ClassWithSomeProtocol()
         testInit(ptr, to: ExistentialWrapper(x: x))
@@ -271,16 +272,73 @@ func testMultiPayloadEnum() {
 
     // CHECK-NEXT: Before deinit
     print("Before deinit")
-        
 
     // CHECK-NEXT: SimpleClass deinitialized!
     testDestroy(ptr)
-    
+
     ptr.deallocate()
 }
 
 testMultiPayloadEnum()
 
+func testNullableRefEnum() {
+    let ptr = UnsafeMutablePointer<NullableRefEnum>.allocate(capacity: 1)
+
+    do {
+        let x = NullableRefEnum.nonEmpty(SimpleClass(x: 23))
+        testInit(ptr, to: x)
+    }
+
+    do {
+        let y = NullableRefEnum.nonEmpty(SimpleClass(x: 28))
+
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: y)
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testNullableRefEnum()
+
+func testForwardToPayloadEnum() {
+    let ptr = UnsafeMutablePointer<ForwardToPayloadEnum>.allocate(capacity: 1)
+
+    do {
+        let x = ForwardToPayloadEnum.nonEmpty(SimpleClass(x: 23), 43)
+        testInit(ptr, to: x)
+    }
+
+    do {
+        let y = ForwardToPayloadEnum.nonEmpty(SimpleClass(x: 28), 65)
+
+        // CHECK: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: y)
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testForwardToPayloadEnum()
+
 #if os(macOS)
 func testObjc() {
     let ptr = UnsafeMutablePointer<ObjcWrapper>.allocate(capacity: 1)
