IRGen should emit code for unused private functions at -Onone -g

This allows for setting breakpoints on such functions and calling them when evaluating expressions in the debugger.

Author: swiftix

lib/IRGen/GenDecl.cpp

@@ -802,8 +802,19 @@ void IRGenerator::emitGlobalTopLevel() {
   bool isWholeModule = PrimaryIGM->getSILModule().isWholeModule();
   for (SILFunction &f : PrimaryIGM->getSILModule()) {
     // Only eagerly emit functions that are externally visible.
-    if (!isPossiblyUsedExternally(f.getLinkage(), isWholeModule))
+    if (!isPossiblyUsedExternally(f.getLinkage(), isWholeModule)) {
+      // This function is not externally visible.
+      // It could be still useful to emit it for debug purposes if it is
+      // a debug build with disabled optimizations.
+      // Do not emit this function if it is coming from a binary SIL file
+      // or if debug info is not supposed to be emitted or if it is a JIT mode.
+      if (!PrimaryIGM->IRGen.Opts.Optimize && !PrimaryIGM->IRGen.Opts.UseJIT &&
+          f.hasLocation() && !f.getLocation().isSILFile() &&
+          PrimaryIGM->DebugInfo) {
+        addLazyFunction(&f);
+      }
       continue;
+    }
 
     CurrentIGMPtr IGM = getGenModule(&f);
     IGM->emitSILFunction(&f);
@@ -1660,6 +1671,16 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(SILFunction *f,
                 llvm::AttributeSet::FunctionIndex, llvm::Attribute::ReadOnly);
   }
   fn = link.createFunction(*this, fnType, cc, attrs, insertBefore);
+  if (forDefinition && !link.isUsed()) {
+    if (IRGen.isLazyFunction(f) &&
+        f->hasLocation() && !f->getLocation().isSILFile() &&
+        link.getName() != SWIFT_ENTRY_POINT_FUNCTION) {
+      // This is a user-defined function and it is an -Onone
+      // compilation. Mark it as used so that LLVM backend
+      // does not remove it.
+      addUsedGlobal(fn);
+    }
+  }
 
   // If we have an order number for this function, set it up as appropriate.
   if (hasOrderNumber) {

lib/IRGen/IRGenModule.h

@@ -281,6 +281,11 @@ class IRGenerator {
     }
   }
 
+
+  bool isLazyFunction(SILFunction *f) const {
+    return LazilyEmittedFunctions.count(f) != 0;
+  }
+
   void addLazyTypeMetadata(CanType type) {
     // Add it to the queue if it hasn't already been put there.
     if (LazilyEmittedTypeMetadata.insert(type).second)

test/IRGen/unused.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-frontend -primary-file %s -emit-ir > %t
+// RUN: FileCheck %s --check-prefix=CHECK-ONONE-NODEBUG --check-prefix=CHECK < %t
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -g > %t.Onone-debug
+// RUN: FileCheck %s --check-prefix=CHECK-ONONE-DEBUG --check-prefix=CHECK < %t.Onone-debug
+
+// Check that unused user-defined functions are preserved at -Onone when -g is used.
+
+// Check that both user functions are marked as used.when using -Onone -g
+// CHECK-ONONE-DEBUG: llvm.used{{.*}}_TF6unused7publicFFT_T_{{.*}}_TF6unusedP33_E4A5FE4B57779A0FC903FD67CDBCAAFB8privateFFT_T_{{.*}}
+
+// Check that private function is not marked as used when -g is not used.
+// CHECK-ONONE-NODEBUG-NOT: llvm.used{{.*}}_TF6unusedP33_E4A5FE4B57779A0FC903FD67CDBCAAFB8privateFFT_T_{{.*}}
+
+// CHECK-ONONE-DEBUG-LABEL: define{{.*}}void @_TF6unusedP33_E4A5FE4B57779A0FC903FD67CDBCAAFB8privateFFT_T_
+// CHECK-ONONE-NODEBUG-NOT: @_TF6unusedP33_E4A5FE4B57779A0FC903FD67CDBCAAFB8privateFFT_T_
+private func privateF() {
+  print(1)
+}
+
+// CHECK-LABEL: define{{.*}}void @_TF6unused7publicFFT_T_() 
+public func publicF() {
+  print(2)
+}
+