[embedded] Add support for (non-generic) classes in embedded Swift

- In embedded Swift, classes get a simplified metadata: Basically just a vtable + destructor + superclass pointer.
- Only non-resilient (intended as permanent restriction), non-generic classes (for now) supported.
- Relax the check that prohibits metadata emission and usage to allow classes.

Author: kubamracek

include/swift/IRGen/Linking.h

@@ -89,6 +89,10 @@ inline bool isEmbedded(CanType t) {
   return t->getASTContext().LangOpts.hasFeature(Feature::Embedded);
 }
 
+inline bool isMetadataAllowedInEmbedded(CanType t) {
+  return isa<ClassType>(t);
+}
+
 inline bool isEmbedded(Decl *d) {
   return d->getASTContext().LangOpts.hasFeature(Feature::Embedded);
 }
@@ -840,7 +844,7 @@ class LinkEntity {
   static LinkEntity forTypeMetadata(CanType concreteType,
                                     TypeMetadataAddress addr) {
     assert(!isObjCImplementation(concreteType));
-    assert(!isEmbedded(concreteType));
+    assert(!isEmbedded(concreteType) || isMetadataAllowedInEmbedded(concreteType));
     LinkEntity entity;
     entity.setForType(Kind::TypeMetadata, concreteType);
     entity.Data |= LINKENTITY_SET_FIELD(MetadataAddress, unsigned(addr));

lib/IRGen/ClassMetadataVisitor.h

@@ -99,6 +99,13 @@ template <class Impl> class ClassMetadataVisitor
     addClassMembers(Target, Target);
   }
 
+  void embeddedLayout() {
+    asImpl().noteAddressPoint();
+    asImpl().addSuperclass();
+    asImpl().addDestructorFunction();
+    addEmbeddedClassMembers(Target);
+  }
+
   /// Notes the beginning of the field offset vector for a particular ancestor
   /// of a generic-layout class.
   void noteStartOfFieldOffsets(ClassDecl *whichClass) {}
@@ -185,6 +192,21 @@ template <class Impl> class ClassMetadataVisitor
     asImpl().addVTableEntries(theClass);
   }
 
+  /// Add fields associated with the given class and its bases.
+  void addEmbeddedClassMembers(ClassDecl *theClass) {
+    // Visit the superclass first.
+    if (auto *superclassDecl = theClass->getSuperclassDecl()) {
+      addEmbeddedClassMembers(superclassDecl);
+    }
+
+    // Note that we have to emit a global variable storing the metadata
+    // start offset, or access remaining fields relative to one.
+    asImpl().noteStartOfImmediateMembers(theClass);
+
+    // Add vtable entries.
+    asImpl().addVTableEntries(theClass);
+  }
+
   friend SILVTableVisitor<Impl>;
   void addMethod(SILDeclRef declRef) {
     // Does this method require a reified runtime vtable entry?

lib/IRGen/GenClass.cpp

@@ -1078,6 +1078,8 @@ void IRGenModule::emitClassDecl(ClassDecl *D) {
   if (!D->getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
     emitClassMetadata(*this, D, fragileLayout, resilientLayout);
     emitFieldDescriptor(D);
+  } else {
+    emitEmbeddedClassMetadata(*this, D, fragileLayout);
   }
 
   IRGen.addClassForEagerInitialization(D);

lib/IRGen/GenDecl.cpp

@@ -4970,6 +4970,11 @@ llvm::GlobalValue *IRGenModule::defineTypeMetadata(
                 : LinkEntity::forTypeMetadata(
                       concreteType, TypeMetadataAddress::FullMetadata));
 
+  if (Context.LangOpts.hasFeature(Feature::Embedded)) {
+    entity = LinkEntity::forTypeMetadata(concreteType,
+                                         TypeMetadataAddress::AddressPoint);
+  }
+
   auto DbgTy = DebugTypeInfo::getGlobalMetadata(
       MetatypeType::get(concreteType),
       entity.getDefaultDeclarationType(*this)->getPointerTo(), Size(0),
@@ -4991,6 +4996,10 @@ llvm::GlobalValue *IRGenModule::defineTypeMetadata(
 
   LinkInfo link = LinkInfo::get(*this, entity, ForDefinition);
   markGlobalAsUsedBasedOnLinkage(*this, link, var);
+  
+  if (Context.LangOpts.hasFeature(Feature::Embedded)) {
+    return var;
+  }
 
   /// For concrete metadata, we want to use the initializer on the
   /// "full metadata", and define the "direct" address point as an alias.

lib/IRGen/GenMeta.cpp

@@ -4967,6 +4967,35 @@ void irgen::emitClassMetadata(IRGenModule &IGM, ClassDecl *classDecl,
   }
 }
 
+void irgen::emitEmbeddedClassMetadata(IRGenModule &IGM, ClassDecl *classDecl,
+                                      const ClassLayout &fragileLayout) {
+  assert(!classDecl->isForeign());
+  PrettyStackTraceDecl stackTraceRAII("emitting metadata for", classDecl);
+
+  // Set up a dummy global to stand in for the metadata object while we produce
+  // relative references.
+  ConstantInitBuilder builder(IGM);
+  auto init = builder.beginStruct();
+  init.setPacked(true);
+
+  auto strategy = IGM.getClassMetadataStrategy(classDecl);
+  assert(strategy == ClassMetadataStrategy::FixedOrUpdate ||
+         strategy == ClassMetadataStrategy::Fixed);
+
+  FixedClassMetadataBuilder metadataBuilder(IGM, classDecl, init,
+                                            fragileLayout);
+  metadataBuilder.embeddedLayout();
+  bool canBeConstant = metadataBuilder.canBeConstant();
+  metadataBuilder.createMetadataAccessFunction();
+
+  CanType declaredType = classDecl->getDeclaredType()->getCanonicalType();
+
+  StringRef section{};
+  bool isPattern = false;
+  auto var = IGM.defineTypeMetadata(declaredType, isPattern, canBeConstant,
+                                    init.finishAndCreateFuture(), section);
+}
+
 void irgen::emitSpecializedGenericClassMetadata(IRGenModule &IGM, CanType type,
                                                 ClassDecl &decl) {
   assert(decl.isGenericContext());

lib/IRGen/GenMeta.h

@@ -59,6 +59,11 @@ namespace irgen {
                          const ClassLayout &fragileLayout,
                          const ClassLayout &resilientLayout);
 
+  /// Emit "embedded Swift" class metadata (a simple vtable) for the given class
+  /// declaration.
+  void emitEmbeddedClassMetadata(IRGenModule &IGM, ClassDecl *theClass,
+                                 const ClassLayout &fragileLayout);
+
   /// Emit the constant initializer of the type metadata candidate for
   /// the given foreign class declaration.
   llvm::Constant *emitForeignTypeMetadataInitializer(IRGenModule &IGM,

lib/IRGen/MetadataRequest.cpp

@@ -3303,7 +3303,8 @@ llvm::Value *IRGenFunction::emitTypeMetadataRef(CanType type) {
 MetadataResponse
 IRGenFunction::emitTypeMetadataRef(CanType type,
                                    DynamicMetadataRequest request) {
-  if (type->getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
+  if (type->getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
+      !isMetadataAllowedInEmbedded(type)) {
     llvm::errs() << "Metadata pointer requested in embedded Swift for type "
                  << type << "\n";
     assert(0 && "metadata used in embedded mode");

test/embedded/classes-no-stdlib.swift

@@ -0,0 +1,32 @@
+// RUN: %target-swift-emit-ir %s -parse-stdlib -enable-experimental-feature Embedded -target arm64e-apple-none | %FileCheck %s
+
+// TODO: investigate why windows is generating more metadata.
+// XFAIL: OS=windows-msvc
+
+public class MyClass {}
+
+// CHECK-DAG: @"$s4main7MyClassCN" = {{.*}}<{ ptr, ptr, ptr }> <{ ptr null, ptr @"$s4main7MyClassCfD", ptr @"$s4main7MyClassCACycfC" }>
+// CHECK-DAG: define {{.*}}ptr @"$s4main7MyClassCfd"
+// CHECK-DAG: define {{.*}}void @"$s4main7MyClassCfD"
+// CHECK-DAG: define {{.*}}ptr @"$s4main7MyClassCACycfC"
+// CHECK-DAG: define {{.*}}ptr @"$s4main7MyClassCACycfc"
+// CHECK-DAG: define {{.*}}%swift.metadata_response @"$s4main7MyClassCMa"
+
+public func foo() -> MyClass {
+  return MyClass()
+}
+// CHECK-DAG: define {{.*}}ptr @"$s4main3fooAA7MyClassCyF"
+
+public class MySubClass: MyClass {}
+
+// CHECK-DAG: @"$s4main10MySubClassCN" = {{.*}}<{ ptr, ptr, ptr }> <{ ptr @"$s4main7MyClassCN", ptr @"$s4main10MySubClassCfD", ptr @"$s4main10MySubClassCACycfC" }>
+// CHECK-DAG: define {{.*}}ptr @"$s4main10MySubClassCACycfC"
+// CHECK-DAG: define {{.*}}ptr @"$s4main10MySubClassCACycfc"
+// CHECK-DAG: define {{.*}}ptr @"$s4main10MySubClassCfd"
+// CHECK-DAG: define {{.*}}void @"$s4main10MySubClassCfD"
+// CHECK-DAG: define {{.*}}%swift.metadata_response @"$s4main10MySubClassCMa"
+
+public func bar() -> MyClass {
+  return MySubClass()
+}
+// CHECK-DAG: define {{.*}}ptr @"$s4main3barAA7MyClassCyF"