[DebugInfo] Dont generate info for __swift_async_resume_project_context or __swift_async_resume_get_context

These functions are alwaysinline and their instructions are created with line 0
as a location. As a result, the instructions all get inlined with line 0 into
funclets. In practice, this makes it so that the first instruction of the
funclet containing a debug location happens much later. This is important
because the inlined instructions do meaningful work, like overwriting the
contents of `fp - 8`.

If we try to set a breakpoint into this funclet, we *must* break before these
instructions, by allowing the line 0 locations to propagate, we fail to do.

This patch changes this by removing all debug locations from the helper
functions. By doing so, when they are inlined, instructions will inherit the
location of the call site.

Author: felipepiovezan

lib/IRGen/GenFunc.cpp

@@ -2590,8 +2590,9 @@ IRGenFunction::emitAsyncResumeProjectContext(llvm::Value *calleeContext) {
 }
 
 llvm::Function *IRGenFunction::getOrCreateResumePrjFn(bool forPrologue) {
-  // The prologue version lacks artificial debug info as this would cause
-  // verification errors when it gets inlined.
+  // Never emit debug info for these alwaysinline functions, as it would create
+  // an inline frame without any user code. These can also be involved in tail
+  // calls, which confuse the debugger.
   auto name = forPrologue ? "__swift_async_resume_project_context_prologue"
                           : "__swift_async_resume_project_context";
   auto Fn = cast<llvm::Function>(IGM.getOrCreateHelperFunction(
@@ -2603,7 +2604,7 @@ llvm::Function *IRGenFunction::getOrCreateResumePrjFn(bool forPrologue) {
         auto callerContext = IGF.emitAsyncResumeProjectContext(addr);
         Builder.CreateRet(callerContext);
       },
-      false /*isNoInline*/, forPrologue));
+      false /*isNoInline*/, true/*for prologue*/));
   Fn->addFnAttr(llvm::Attribute::AlwaysInline);
   return Fn;
 }
@@ -2694,14 +2695,17 @@ void IRGenFunction::emitSuspensionPoint(Explosion &toExecutor,
 }
 
 llvm::Function *IRGenFunction::getOrCreateResumeFromSuspensionFn() {
+  // Never emit debug info for these alwaysinline functions, as it would create
+  // an inline frame without any user code. These can also be involved in tail
+  // calls, which confuse the debugger.
   auto name = "__swift_async_resume_get_context";
   auto fn = cast<llvm::Function>(IGM.getOrCreateHelperFunction(
       name, IGM.Int8PtrTy, {IGM.Int8PtrTy},
       [&](IRGenFunction &IGF) {
         auto &Builder = IGF.Builder;
         Builder.CreateRet(&*IGF.CurFn->arg_begin());
       },
-      false /*isNoInline*/));
+      false /*isNoInline*/, true /*forPrologue*/));
   fn->addFnAttr(llvm::Attribute::AlwaysInline);
   return fn;
 }

test/IRGen/async/no_debug_info_in_projections.sil

@@ -0,0 +1,48 @@
+// RUN: %target-swift-frontend %s -g -emit-irgen | %IRGenFileCheck %s
+
+// We don't want any debug info for these helper functions:
+
+// CHECK: define {{.*}} @__swift_async_resume_project_context
+// CHECK-NOT: !dbg
+// CHECK-SAME: {
+// CHECK: define {{.*}} @__swift_async_resume_get_context
+// CHECK-NOT: !dbg
+// CHECK-SAME: {
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import SwiftShims
+
+@_silgen_name("some_async_func")
+public func some_async_func() async -> Int
+
+func foo() async -> Int
+
+sil_scope 1 {  parent @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 }
+
+sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
+bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
+  %2 = integer_literal $Builtin.Int32, 0, scope 1 // user: %3
+  %3 = struct $Int32 (%2 : $Builtin.Int32), scope 1 // user: %4
+  return %3 : $Int32, scope 1                     // id: %4
+}
+
+sil_scope 2 { loc "test.swift":4:6 parent @$s4test3fooSiyYaF : $@convention(thin) @async () -> Int }
+sil_scope 3 { loc "test.swift":5:16 parent 2 }
+sil_scope 4 { loc "test.swift":5:7 parent 2 }
+
+sil @$s4test3fooSiyYaF : $@convention(thin) @async () -> Int {
+bb0:
+  %0 = enum $Optional<Builtin.Executor>, #Optional.none!enumelt, loc * "test.swift":4:6, scope 2 // user: %3
+  // function_ref some_async_func
+  %1 = function_ref @some_async_func : $@convention(thin) @async () -> Int, loc "test.swift":5:22, scope 3 // user: %2
+  %2 = apply %1() : $@convention(thin) @async () -> Int, loc "test.swift":5:22, scope 3 // users: %6, %4
+  hop_to_executor %0 : $Optional<Builtin.Executor>, loc * "test.swift":5:22, scope 3 // id: %3
+  debug_value %2 : $Int, let, name "result", loc "test.swift":5:7, scope 4 // id: %4
+  return %2 : $Int, loc "test.swift":6:3, scope 4 // id: %13
+}
+
+
+sil @some_async_func : $@convention(thin) @async () -> Int