[LLDB] Recognize `std::noop_coroutine()` in `std::coroutine_handle` pretty printer

[avogelsgesang]

Summary

With this commit, the std::coroutine_handle pretty printer now
recognizes std::noop_coroutine() handles. For noop coroutine handles,
we identify use the summary string noop_coroutine and we don't print
children

Instead of

(std::coroutine_handle<void>) $3 = coro frame = 0x555555559058 {
  resume = 0x00005555555564f0 (a.out`std::__1::coroutine_handle<std::__1::noop_coroutine_promise>::__noop_coroutine_frame_ty_::__dummy_resume_destroy_func() at noop_coroutine_handle.h:79)
  destroy = 0x00005555555564f0 (a.out`std::__1::coroutine_handle<std::__1::noop_coroutine_promise>::__noop_coroutine_frame_ty_::__dummy_resume_destroy_func() at noop_coroutine_handle.h:79)
}

we now print

(std::coroutine_handle<void>) $3 = noop_coroutine

[avogelsgesang]

Exclude unsupported compilers from test case

[avogelsgesang]

rebase

[avogelsgesang]

fix offset

[avogelsgesang]

fix test case

[ChuanqiXu]

The summary looks good to me.

lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp

83

Maybe IsNoopCoro or something else looks better?

[avogelsgesang]

rename IsNoopResumeDestroy -> IsNoopCoroFunction

[avogelsgesang]

As discussed via email, the reason for the test failures on green dragon is, that green dragon seems to be using some compiler which passes the test

if not (is_clang and self.expectedCompilerVersion(["<", "16"])):

but does not actually provide the expected debug informations. @jasonmolenda Do you know which exact compiler is used on green-dragon?

[aprantl]

In D132735#3959530, @avogelsgesang wrote:

As discussed via email, the reason for the test failures on green dragon is, that green dragon seems to be using some compiler which passes the test

if not (is_clang and self.expectedCompilerVersion(["<", "16"])):

but does not actually provide the expected debug informations. @jasonmolenda Do you know which exact compiler is used on green-dragon?

The lldb incremental bot uses the last good build from the https://green.lab.llvm.org/green/job/clang-stage1-RA/ bot as the clang compiler.

[avogelsgesang]

I reapplied this patch locally on top of the latest main and tried to reproduce the issue on my Mac using

cmake -B build -G Ninja -C lldb/cmake/caches/Apple-lldb-macOS.cmake -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi" -DLLVM_ENABLE_PROJECTS="clang;lldb" llvm
ninja check-lldb

This gives me 10 failing tests, but none of them are related to the coroutine_handle pretty printer.

If I run

./bin/llvm-lit ../lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle

I get

UNSUPPORTED: lldb-api :: functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py (1 of 1)

No idea why this test is marked as unsupportd.
Any idea how I can run this test case locally on my mac?

lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp

static ValueObjectSP GetCoroFramePtrFromHandle(ValueObject &valobj) {
   if (!ptr_sp)
     return nullptr;
   if (!ptr_sp->GetCompilerType().IsPointerType())
     return nullptr;
 
   return ptr_sp;
 }
 
-static Function *ExtractDestroyFunction(ValueObjectSP &frame_ptr_sp) {
+static Function *ExtractFunction(ValueObjectSP &frame_ptr_sp, int offset) {
   lldb::TargetSP target_sp = frame_ptr_sp->GetTargetSP();
   lldb::ProcessSP process_sp = frame_ptr_sp->GetProcessSP();
   auto ptr_size = process_sp->GetAddressByteSize();
 
   AddressType addr_type;
   lldb::addr_t frame_ptr_addr = frame_ptr_sp->GetPointerValue(&addr_type);
   if (!frame_ptr_addr || frame_ptr_addr == LLDB_INVALID_ADDRESS)
     return nullptr;
   lldbassert(addr_type == AddressType::eAddressTypeLoad);
 
   Status error;
-  // The destroy pointer is the 2nd pointer inside the compiler-generated
-  // `pair<resumePtr,destroyPtr>`.
-  auto destroy_func_ptr_addr = frame_ptr_addr + ptr_size;
-  lldb::addr_t destroy_func_addr =
-      process_sp->ReadPointerFromMemory(destroy_func_ptr_addr, error);
+  auto func_ptr_addr = frame_ptr_addr + offset * ptr_size;
+  lldb::addr_t func_addr =
+      process_sp->ReadPointerFromMemory(func_ptr_addr, error);
   if (error.Fail())
     return nullptr;
 
-  Address destroy_func_address;
-  if (!target_sp->ResolveLoadAddress(destroy_func_addr, destroy_func_address))
+  Address func_address;
+  if (!target_sp->ResolveLoadAddress(func_addr, func_address))
     return nullptr;
 
-  Function *destroy_func =
-      destroy_func_address.CalculateSymbolContextFunction();
-  if (!destroy_func)
-    return nullptr;
+  return func_address.CalculateSymbolContextFunction();
+}
+
+static Function *ExtractResumeFunction(ValueObjectSP &frame_ptr_sp) {
+  return ExtractFunction(frame_ptr_sp, 0);
+}
 
-  return destroy_func;
+static Function *ExtractDestroyFunction(ValueObjectSP &frame_ptr_sp) {
+  return ExtractFunction(frame_ptr_sp, 1);
+}
+
+static bool IsNoopCoroFunction(Function *f) {
+  if (!f)
+    return false;
+
+  // clang's `__builtin_coro_noop` gets lowered to
+  // `_NoopCoro_ResumeDestroy`. This is used by libc++
+  // on clang.
+  auto mangledName = f->GetMangled().GetMangledName();
+  if (mangledName == "__NoopCoro_ResumeDestroy")
+    return true;
+
+  // libc++ uses the following name as a fallback on
+  // compilers without `__builtin_coro_noop`.
+  auto name = f->GetNameNoArguments();
+  static RegularExpression libcxxRegex(
+      "^std::coroutine_handle<std::noop_coroutine_promise>::"
+      "__noop_coroutine_frame_ty_::__dummy_resume_destroy_func$");
+  lldbassert(libcxxRegex.IsValid());
+  if (libcxxRegex.Execute(name.GetStringRef()))
+    return true;
+  static RegularExpression libcxxRegexAbiNS(
+      "^std::__[[:alnum:]]+::coroutine_handle<std::__[[:alnum:]]+::"
+      "noop_coroutine_promise>::__noop_coroutine_frame_ty_::"
+      "__dummy_resume_destroy_func$");
+  lldbassert(libcxxRegexAbiNS.IsValid());
+  if (libcxxRegexAbiNS.Execute(name.GetStringRef()))
+    return true;
+
+  // libstdc++ uses the following name on both gcc and clang.
+  static RegularExpression libstdcppRegex(
+      "^std::__[[:alnum:]]+::coroutine_handle<std::__[[:alnum:]]+::"
+      "noop_coroutine_promise>::__frame::__dummy_resume_destroy$");
+  lldbassert(libstdcppRegex.IsValid());
+  if (libstdcppRegex.Execute(name.GetStringRef()))
+    return true;
+
+  return false;
 }
 
 static CompilerType InferPromiseType(Function &destroy_func) {
   Block &block = destroy_func.GetBlock(true);
   auto variable_list = block.GetBlockVariableList(true);
 
   // clang generates an artificial `__promise` variable inside the
   // `destroy` function. Look for it.

 bool lldb_private::formatters::StdlibCoroutineHandleSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP ptr_sp(GetCoroFramePtrFromHandle(valobj));
   if (!ptr_sp)
     return false;
 
   if (!ptr_sp->GetValueAsUnsigned(0)) {
     stream << "nullptr";
-  } else {
-    stream.Printf("coro frame = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
+    return true;
   }
+  if (IsNoopCoroFunction(ExtractResumeFunction(ptr_sp)) &&
+      IsNoopCoroFunction(ExtractDestroyFunction(ptr_sp))) {
+    stream << "noop_coroutine";
+    return true;
+  }
+
+  stream.Printf("coro frame = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
   return true;
 }
 
 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     StdlibCoroutineHandleSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp),
       m_ast_importer(std::make_unique<ClangASTImporter>()) {
   if (valobj_sp)
bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
 
   ValueObjectSP ptr_sp(GetCoroFramePtrFromHandle(m_backend));
   if (!ptr_sp)
     return false;
 
+  Function *resume_func = ExtractResumeFunction(ptr_sp);
+  Function *destroy_func = ExtractDestroyFunction(ptr_sp);
+
+  if (IsNoopCoroFunction(resume_func) && IsNoopCoroFunction(destroy_func)) {
+    // For `std::noop_coroutine()`, we don't want to display any child nodes.
+    return false;
+  }
+
   // Get the `promise_type` from the template argument
   CompilerType promise_type(
       valobj_sp->GetCompilerType().GetTypeTemplateArgument(0));
   if (!promise_type)
     return false;
 
   // Try to infer the promise_type if it was type-erased
   auto ts = valobj_sp->GetCompilerType().GetTypeSystem();
   auto ast_ctx = ts.dyn_cast_or_null<TypeSystemClang>();
   if (!ast_ctx)
     return false;
-  if (promise_type.IsVoidType()) {
-    if (Function *destroy_func = ExtractDestroyFunction(ptr_sp)) {
-      if (CompilerType inferred_type = InferPromiseType(*destroy_func)) {
-        // Copy the type over to the correct `TypeSystemClang` instance
-        promise_type = m_ast_importer->CopyType(*ast_ctx, inferred_type);
-      }
-    }
-  }
+  if (promise_type.IsVoidType() && destroy_func) {
 
   // Build the coroutine frame type
   CompilerType coro_frame_type = GetCoroutineFrameType(*ast_ctx, promise_type);
 
   m_frame_ptr_sp = ptr_sp->Cast(coro_frame_type.GetPointerType());
 
   return false;
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py

def do_test(self, stdlib_type):
             result_summary=re.compile("^coro frame = 0x[0-9a-f]*$"),
             result_children=[
                 ValueCheck(name="resume", summary = test_generator_func_ptr_re),
                 ValueCheck(name="destroy", summary = test_generator_func_ptr_re),
                 ValueCheck(name="promise", children=[
                     ValueCheck(name="current_value", value = "-1"),
                 ])
             ])
+        # We recognize and pretty-print `std::noop_coroutine`. We don't display
+        # any children as those are irrelevant for the noop coroutine.
+        # clang version < 16 did not yet write debug info for the noop coroutines.
+        if not (is_clang and self.expectedCompilerVersion(["<", "16"])):
+            self.expect_expr("noop_hdl",
+                result_summary="noop_coroutine",
+                result_children=[])
         if is_clang:
             # For a type-erased `coroutine_handle<>`, we can still devirtualize
             # the promise call and display the correctly typed promise.
             self.expect_expr("type_erased_hdl",
                 result_summary=re.compile("^coro frame = 0x[0-9a-f]*$"),
                 result_children=[
                     ValueCheck(name="resume", summary = test_generator_func_ptr_re),
                     ValueCheck(name="destroy", summary = test_generator_func_ptr_re),

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/main.cpp

 void empty_function_so_we_can_set_a_breakpoint() {}
 
 int main() {
   bool is_supported = is_implementation_supported();
   int_generator gen = my_generator_func();
   std::coroutine_handle<> type_erased_hdl = gen.hdl;
   std::coroutine_handle<int> incorrectly_typed_hdl =
       std::coroutine_handle<int>::from_address(gen.hdl.address());
+  std::coroutine_handle<> noop_hdl = std::noop_coroutine();
   gen.hdl.resume();                            // Break at initial_suspend
   gen.hdl.resume();                            // Break after co_yield
   empty_function_so_we_can_set_a_breakpoint(); // Break at final_suspend
 }