[embedded] Remove unspecialized functions before running IRGen

Author: kubamracek

lib/IRGen/GenDecl.cpp

@@ -1261,6 +1261,11 @@ static bool isLazilyEmittedFunction(SILFunction &f, SILModule &m) {
   return true;
 }
 
+static bool loweredFunctionHasGenericArguments(SILFunction *f) {
+  auto s = f->getLoweredFunctionType()->getInvocationGenericSignature();
+  return s && !s->areAllParamsConcrete();
+}
+
 void IRGenerator::emitGlobalTopLevel(
     const std::vector<std::string> &linkerDirectives) {
   // Generate order numbers for the functions in the SIL module that
@@ -1294,6 +1299,19 @@ void IRGenerator::emitGlobalTopLevel(
   // Emit SIL functions.
   auto &m = PrimaryIGM->getSILModule();
   for (SILFunction &f : m) {
+    // Generic functions should not be present in embedded Swift.
+    //
+    // TODO: Cannot enable this check yet because we first need removal of
+    // unspecialized classes and class vtables in SIL.
+    //
+    // if (SIL.getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
+    //   bool isGeneric = loweredFunctionHasGenericArguments(&f);
+    //   if (isGeneric) {
+    //     llvm::errs() << "Unspecialized function: \n" << f << "\n";
+    //     assert(0 && "unspecialized function present in embedded Swift");
+    //   }
+    // }
+
     if (isLazilyEmittedFunction(f, m))
       continue;
 
@@ -1407,11 +1425,6 @@ deleteAndReenqueueForEmissionValuesDependentOnCanonicalPrespecializedMetadataRec
   emitLazyTypeContextDescriptor(IGM, &decl, RequireMetadata);
 }
 
-static bool loweredFunctionHasGenericArguments(SILFunction *f) {
-  auto s = f->getLoweredFunctionType()->getInvocationGenericSignature();
-  return s && !s->areAllParamsConcrete();
-}
-
 /// Emit any lazy definitions (of globals or functions or whatever
 /// else) that we require.
 void IRGenerator::emitLazyDefinitions() {

lib/SIL/IR/SILFunction.cpp

@@ -842,6 +842,11 @@ bool SILFunction::hasValidLinkageForFragileRef() const {
   return hasPublicVisibility(getLinkage());
 }
 
+static bool loweredFunctionHasGenericArguments(const SILFunction *f) {
+  auto s = f->getLoweredFunctionType()->getInvocationGenericSignature();
+  return s && !s->areAllParamsConcrete();
+}
+
 bool
 SILFunction::isPossiblyUsedExternally() const {
   auto linkage = getLinkage();
@@ -869,6 +874,13 @@ SILFunction::isPossiblyUsedExternally() const {
       hasOpaqueResultTypeWithAvailabilityConditions())
     return true;
 
+  // In embedded Swift, generic functions, even public ones cannot be used
+  // externally.
+  bool embedded = getASTContext().LangOpts.hasFeature(Feature::Embedded);
+  bool generic = loweredFunctionHasGenericArguments(this);
+  if (embedded && generic)
+    return false;
+
   return swift::isPossiblyUsedExternally(linkage, getModule().isWholeModule());
 }
 

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -148,6 +148,7 @@ class DeadFunctionAndGlobalElimination {
 
   /// Marks a function as alive.
   void makeAlive(SILFunction *F) {
+    LLVM_DEBUG(llvm::dbgs() << "         makeAlive " << F->getName() << '\n');
     AliveFunctionsAndTables.insert(F);
     assert(F && "function does not exist");
     Worklist.insert(F);
@@ -431,7 +432,11 @@ class DeadFunctionAndGlobalElimination {
       F.forEachSpecializeAttrTargetFunction(
           [this](SILFunction *targetFun) { ensureAlive(targetFun); });
 
-      if (!F.shouldOptimize()) {
+      bool retainBecauseFunctionIsNoOpt = !F.shouldOptimize();
+      if (Module->getASTContext().LangOpts.hasFeature(Feature::Embedded))
+        retainBecauseFunctionIsNoOpt = false;
+
+      if (retainBecauseFunctionIsNoOpt) {
         LLVM_DEBUG(llvm::dbgs() << "  anchor a no optimization function: "
                                 << F.getName() << "\n");
         ensureAlive(&F);
@@ -526,6 +531,8 @@ class DeadFunctionAndGlobalElimination {
 
     // Check vtable methods.
     for (auto &vTable : Module->getVTables()) {
+      LLVM_DEBUG(llvm::dbgs() << " processing vtable "
+                              << vTable->getClass()->getName() << '\n');
       for (const SILVTable::Entry &entry : vTable->getEntries()) {
         if (entry.getMethod().kind == SILDeclRef::Kind::Deallocator ||
             entry.getMethod().kind == SILDeclRef::Kind::IVarDestroyer) {

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -891,6 +891,9 @@ SILPassPipelinePlan::getIRGenPreparePassPipeline(const SILOptions &Options) {
   // boundaries as required by the ABI.
   P.addLoadableByAddress();
 
+  // For embedded Swift: Remove all unspecialized functions.
+  P.addLateDeadFunctionAndGlobalElimination();
+
   if (Options.EnablePackMetadataStackPromotion) {
     // Insert marker instructions indicating where on-stack pack metadata
     // deallocation must occur.

test/embedded/classes-methods-no-stdlib.swift

@@ -9,7 +9,7 @@ public class MySubClass: MyClass {
   override func foo() { }
 }
 
-// CHECK: @"$s4main7MyClassCN" = {{.*}}<{ ptr, ptr, ptr, ptr, ptr }> <{ ptr null, ptr @"$s4main7MyClassCfD", ptr @"$s4main7MyClassC3fooyyF", ptr @"$s4main7MyClassC3baryyF", ptr @"$s4main7MyClassCACycfC" }>
+// CHECK: @"$s4main7MyClassCN" = {{.*}}<{ ptr, ptr, ptr, ptr, ptr }> <{ ptr null, ptr @"$s4main7MyClassCfD", ptr @"$s4main7MyClassC3fooyyF", ptr @"$s4main7MyClassC3baryyF", ptr @swift_deletedMethodError }>
 // CHECK: @"$s4main10MySubClassCN" = {{.*}}<{ ptr, ptr, ptr, ptr, ptr }> <{ ptr @"$s4main7MyClassCN", ptr @"$s4main10MySubClassCfD", ptr @"$s4main10MySubClassC3fooyyF", ptr @"$s4main7MyClassC3baryyF", ptr @"$s4main10MySubClassCACycfC" }>
 
 // CHECK: define {{.*}}void @"$s4main4test1xyAA7MyClassC_tF"(ptr %0)

test/embedded/debuginfo.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-frontend -g -emit-ir %s -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -g -O -emit-ir %s -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -g -Osize -emit-ir %s -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -emit-ir %s -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -O -emit-ir %s -enable-experimental-feature Embedded
+// RUN: %target-swift-frontend -Osize -emit-ir %s -enable-experimental-feature Embedded
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+public func foo<T>(_ array: inout [T]) {
+    array.withUnsafeMutableBytes {
+        $0[0] = 0
+    }
+}
+
+func foo2<T>(_ array: inout [T]) {
+    array.withUnsafeMutableBytes {
+        $0[0] = 0
+    }
+}
+
+public func test() {
+    var a: [UInt8] = [1, 2, 3]
+    foo(&a)
+    foo2(&a)
+}