[LLDB] Do not dereference promise pointer in `coroutine_handle` pretty printer

[avogelsgesang]

Summary

So far, the pretty printer for std::coroutine_handle internally
dereferenced the contained frame pointer displayed the promise
as a sub-value. As noticed in https://reviews.llvm.org/D132624
by @labath, this can lead to an endless loop in lldb during printing
if the coroutine frame pointers form a cycle.

This commit breaks the cycle by exposing the promise as a pointer
type instead of a value type. The depth to which the frame variable
and the expression commands dereference those pointers can be
controlled using the --ptr-depth argument.

[labath]

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

246–248

Have you checked there won't be a use-after-free problem here, given that this data extractor will refer to the stack object?

To create persistent data, you need to use the DataBufferSP constructor, but I'm wondering if we couldn't fix this by creating the (non-pointer) object using the CreateValueObjectFromAddress function, as above, but then actually use valobj->AddressOf as the synthetic child.

I am also somewhat surprised that we need to use the GetAddressOf trick here, as this seems to indicate that the coroutine contains (in the proper C "subobject" kind of way) the promise object. That's not necessarily wrong, but it makes me think we may be "breaking the cycle" at the wrong place.

[avogelsgesang]

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

246–248

Thanks for taking a look!

To create persistent data, you need to use the DataBufferSP constructor

good point, I will keep this in mind as a fallback in case we don't decide to follow any of the other directions you hinted at.

wondering if we couldn't fix this by creating the (non-pointer) object using the CreateValueObjectFromAddress function, as above, but then actually use valobj->AddressOf as the synthetic child

Good idea! I will give it a try

[...] as this seems to indicate that the coroutine contains (in the proper C "subobject" kind of way) the promise object. That's not necessarily wrong, but it makes me think we may be "breaking the cycle" at the wrong place.

The physical layout of this is:

// in the standard library
template<typename promise_type>
struct exception_handle<promise_type> {
    __coro_frame<promise_type>* __hdl; // <--- this is the pointer we read with `GetCoroFramePtrFromHandle`
};

// compiler-generated coroutine frame. Generated ad-hoc per coroutine
struct __coro_frame<promise_type> {
     // The ABI guaranteees that hose two pointers are always the first two pointers in the struct.
     void (*resume)(void*); // function pointer for type erasure
     void (*destroy)(void*); // function pointer for type erasure
     // Next comes our promise type. This is under the control of the program author
     promise_type promise;
     // Next comes any compiler-generated, internal state which gets persisted across suspension points. 
     // The functions pointed to by `resume`/`destroy` know how to interpret this part of the coroutine frame.
     int __suspension_point_id;
     double __some_internal_state;
     std::string __some_other_internal_state;
     ....
};

The programmer (i.e., most likely the user of this pretty-printer), wrote only the "promise" explicitly in his code. Everything else is compiler-generated. As such, the lldb-user will usually look for the "promise" first, and I would like to make it easy to find it, by exposing it as a top-level children of the exception_handle instead of hiding it inside a sub-child.

[labath]

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

246–248

As such, the lldb-user will usually look for the "promise" first, and I would like to make it easy to find it, by exposing it as a top-level children of the exception_handle instead of hiding it inside a sub-child.

That makes sense. And I think that's a good argument for automatically "dereferencing" that object (i.e., status quo). That said, it's not fully clear to me how do we end up looping here. I take it the promise object contains a (compiler-generated ?) pointer to another __coro_frame object? What would happen if we turned *that* into a pointer?

[avogelsgesang]

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

246–248

I take it the promise object contains a [...] pointer to another __coro_frame object?

yes

(compiler-generated ?)

no

We end up looping if the user explicitly puts an coroutine_handle inside promise_type. You can find an example of this in https://clang.llvm.org/docs/DebuggingCoroutines.html#get-the-asynchronous-stack, in particular

struct promise_type {
    // [...] shortened for readability

    std::coroutine_handle<> continuation = std::noop_coroutine();
    int result = 0;
};

In asynchronous programming, it is common to "chain continuations" by putting a coroutine_handle into the promise_type. This coroutine_handle inside the promise_type gives my asynchronous coroutine the answer to the question "where should I continue next, after finishing the asychronous operation modelled by my own coroutine?".

In normal situations (i.e. in the absence of bugs inside the debugged program), those coroutine_handle's should not form cycles. But I guess there could also be other use cases for coroutines where coroutine_handle cycles might be useful...

What would happen if we turned *that* into a pointer?

The promise_type is a user-written struct, so I guess that I have little leverage whether it contains a coroutine_handle by value or by pointer? And turning an object which the user wrote as "by value" into a "by pointer" representation in the debugger would be pretty surprising...

[labath]

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

246–248

Ok, thanks for your patience, I think I finally understand what's going on. Given all of the above, the approach in this patch (not dereferencing the promise type) makes sense to me, since the coroutine_handletype has pointer-like semantics. However, do take my opinion with a grain of salt, since I probably not going to be using this code.

[hawkinsw]

I hope that these comments are helpful. If they are not, please feel free to tell me to stop! I appreciated learning from reading through your discussion with @labath !

lldb/packages/Python/lldbsuite/test/lldbtest.py

265

nit: typo Derefence => Dereference

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

19

Do we want to return a lldb::addr_t? I know that they are likely the same, but do we want it for consistency?

I see (below) several instances where we are passing around "addresses" and they are plain uint64_t so I am obviously being unhelpful. Sorry!

[avogelsgesang]

address review comments

[avogelsgesang]

wondering if we couldn't fix this by creating the (non-pointer) object using the CreateValueObjectFromAddress function, as above, but then actually use valobj->AddressOf as the synthetic child

yes, that worked quite nicely

[avogelsgesang]

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

19

changed to lldb::addr_t in this complete file

[aprantl]

Seems fine if Pavel is happy with it.

lldb/packages/Python/lldbsuite/test/lldbtest.py

249

That looks like a useful addition!

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

21

Some day we should start returning Optional<addr_t> ...

212

.

[labath]

Seems fine (with the caveat that all I know about coroutines was learned in this review).

[jasonmolenda]

I reverted this change for now to unblock the macOS CI bots.

commit a410b34a66accd864b174b6330d3d353e73f54d8
Author: Jason Molenda <[e-mail]>
Date:   Fri Nov 25 12:15:47 2022 -0800

    Revert "[LLDB] Do not dereference promise pointer in `coroutine_handle` pretty printer"
    
    This reverts commit cd3091a88f7c55c90d9b5fff372ce1cdfc71948d.
    
    This change crashes on macOS systems in
    formatters::StdlibCoroutineHandleSyntheticFrontEnd when
    it fails to create the `ValueObjectSP promise` and calls
    a method on it.  The failure causes a segfault while running
    TestCoroutineHandle.py on the "LLDB Incremental" CI bot,
    https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/
    
    This change originally landed via https://reviews.llvm.org/D132815

I saw in the description, " As noticed in https://reviews.llvm.org/D132624
by @labath, this can lead to an endless loop in lldb during printing
if the coroutine frame pointers form a cycle." - if we should revert further changes until this can be all addressed, that's fine, we'll see how the bots react.

[avogelsgesang]

The issue with this change was that if devirtualization is failing, then in the line

lldb::ValueObjectSP promise = CreateValueObjectFromAddress(
      "promise", frame_ptr_addr + 2 * ptr_size, exe_ctx, promise_type);

the promise_type is void. Creating an object of type void is obviously not possible.

Adding a simple additional !promise_type.isVoid() check will fix this. Waiting for resolution of the test failure on https://reviews.llvm.org/D132735 first, though.

[avogelsgesang]

fix crash in cases where the promise type is unknown even after an attempt at devirtualization

[avogelsgesang]

Since I am still blocked on solving the Apple-specific issues in https://reviews.llvm.org/D132735 and couldn't solve them in time for LLVM-16, I now rebased this change directly on main, so that it no longer depends on the refactorings from the other commit.

My idea is to backport this change to LLVM-16 after it landed successfully on main. I think including this commit in LLVM-16 makes sense, because I see it as a "bug fix": it fixes a potential infinite loop in the debugger.

https://reviews.llvm.org/D132735 on the other hand can wait until LLVM-17, given it's only a usability improvement/new feature.

lldb/packages/Python/lldbsuite/test/lldbtest.py

else:
         for path in os.environ["PATH"].split(os.pathsep):
             exe_file = os.path.join(path, program)
             if is_exe(exe_file):
                 return exe_file
     return None
 
 class ValueCheck:
     def __init__(self, name=None, value=None, type=None, summary=None,
-                 children=None):
+                 children=None, dereference=None):
         """
         :param name: The name that the SBValue should have. None if the summary
                      should not be checked.
         :param summary: The summary that the SBValue should have. None if the
                         summary should not be checked.
         :param value: The value that the SBValue should have. None if the value
                       should not be checked.
         :param type: The type that the SBValue result should have. None if the
                      type should not be checked.
         :param children: A list of ValueChecks that need to match the children
                          of this SBValue. None if children shouldn't be checked.
                          The order of checks is the order of the checks in the
                          list. The number of checks has to match the number of
                          children.
+        :param dereference: A ValueCheck for the SBValue returned by the
+                            `Derefence` function.
         """
         self.expect_name = name
         self.expect_value = value
         self.expect_type = type
         self.expect_summary = summary
         self.children = children
+        self.dereference = dereference
 
     def check_value(self, test_base, val, error_msg=None):
         """
         Checks that the given value matches the currently set properties
         of this ValueCheck. If a match failed, the given TestBase will
         be used to emit an error. A custom error message can be specified
         that will be used to describe failed check for this SBValue (but
         not errors in the child values).
def check_value(self, test_base, val, error_msg=None):
                 test_base.assertRegex(val.GetSummary(), self.expect_summary,
                                       this_error_msg)
             else:
                 test_base.assertEqual(self.expect_summary, val.GetSummary(),
                                       this_error_msg)
         if self.children is not None:
             self.check_value_children(test_base, val, error_msg)
 
+        if self.dereference is not None:
+            self.dereference.check_value(test_base, val.Dereference(), error_msg)
+
     def check_value_children(self, test_base, val, error_msg=None):
         """
         Checks that the children of a SBValue match a certain structure and
         have certain properties.
 
         :param test_base: The current test's TestBase object.
         :param val: The SBValue to check.
         """

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

public:
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  lldb::ValueObjectSP m_frame_ptr_sp;
+  lldb::ValueObjectSP m_resume_ptr_sp;
+  lldb::ValueObjectSP m_destroy_ptr_sp;
+  lldb::ValueObjectSP m_promise_ptr_sp;
 };
 
 SyntheticChildrenFrontEnd *
 StdlibCoroutineHandleSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                               lldb::ValueObjectSP);
 
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_COROUTINES_H

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

 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/VariableList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-static ValueObjectSP GetCoroFramePtrFromHandle(ValueObject &valobj) {
-  ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
+static uint64_t GetCoroFramePtrFromHandle(ValueObjectSP valobj_sp) {
   if (!valobj_sp)
-    return nullptr;
+    return LLDB_INVALID_ADDRESS;
 
   // We expect a single pointer in the `coroutine_handle` class.
   // We don't care about its name.
   if (valobj_sp->GetNumChildren() != 1)
-    return nullptr;
+    return LLDB_INVALID_ADDRESS;
   ValueObjectSP ptr_sp(valobj_sp->GetChildAtIndex(0, true));
   if (!ptr_sp)
-    return nullptr;
+    return LLDB_INVALID_ADDRESS;
   if (!ptr_sp->GetCompilerType().IsPointerType())
-    return nullptr;
-
-  return 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();
+    return LLDB_INVALID_ADDRESS;
 
   AddressType addr_type;
-  lldb::addr_t frame_ptr_addr = frame_ptr_sp->GetPointerValue(&addr_type);
+  lldb::addr_t frame_ptr_addr = ptr_sp->GetPointerValue(&addr_type);
   if (!frame_ptr_addr || frame_ptr_addr == LLDB_INVALID_ADDRESS)
-    return nullptr;
+    return LLDB_INVALID_ADDRESS;
   lldbassert(addr_type == AddressType::eAddressTypeLoad);
+  if (addr_type != AddressType::eAddressTypeLoad)
+    return LLDB_INVALID_ADDRESS;
+
+  return frame_ptr_addr;
+}
+
+static Function *ExtractFunction(lldb::TargetSP target_sp,
+                                 uint64_t frame_ptr_addr, int offset) {
+  lldb::ProcessSP process_sp = target_sp->GetProcessSP();
+  auto ptr_size = process_sp->GetAddressByteSize();
 
   Status 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 func_address;
   if (!target_sp->ResolveLoadAddress(func_addr, func_address))
     return nullptr;
 
   return func_address.CalculateSymbolContextFunction();
 }
 
-static Function *ExtractResumeFunction(ValueObjectSP &frame_ptr_sp) {
-  return ExtractFunction(frame_ptr_sp, 0);
+static Function *ExtractResumeFunction(lldb::TargetSP target_sp,
+                                       uint64_t frame_ptr_addr) {
+  return ExtractFunction(target_sp, frame_ptr_addr, 0);
 }
 
-static Function *ExtractDestroyFunction(ValueObjectSP &frame_ptr_sp) {
-  return ExtractFunction(frame_ptr_sp, 1);
+static Function *ExtractDestroyFunction(lldb::TargetSP target_sp,
+                                        uint64_t frame_ptr_addr) {
+  return ExtractFunction(target_sp, frame_ptr_addr, 1);
 }
 
 static bool IsNoopResumeDestroy(Function *f) {
   if (!f)
     return false;
 
   // clang's `__builtin_coro_noop` gets lowered to
   // `_NoopCoro_ResumeDestroy`. This is used by libc++
if (!promise_var->IsArtificial())
     return {};
 
   Type *promise_type = promise_var->GetType();
   if (!promise_type)
     return {};
   return promise_type->GetForwardCompilerType();
 }
 
-static CompilerType GetCoroutineFrameType(TypeSystemClang &ast_ctx,
-                                          CompilerType promise_type) {
-  CompilerType void_type = ast_ctx.GetBasicType(lldb::eBasicTypeVoid);
-  CompilerType coro_func_type = ast_ctx.CreateFunctionType(
-      /*result_type=*/void_type, /*args=*/&void_type, /*num_args=*/1,
-      /*is_variadic=*/false, /*qualifiers=*/0);
-  CompilerType coro_abi_type;
-  if (promise_type.IsVoidType()) {
-    coro_abi_type = ast_ctx.CreateStructForIdentifier(
-        ConstString(), {{"resume", coro_func_type.GetPointerType()},
-                        {"destroy", coro_func_type.GetPointerType()}});
-  } else {
-    coro_abi_type = ast_ctx.CreateStructForIdentifier(
-        ConstString(), {{"resume", coro_func_type.GetPointerType()},
-                        {"destroy", coro_func_type.GetPointerType()},
-                        {"promise", promise_type}});
-  }
-  return coro_abi_type;
-}
-
 bool lldb_private::formatters::StdlibCoroutineHandleSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  ValueObjectSP ptr_sp(GetCoroFramePtrFromHandle(valobj));
-  if (!ptr_sp)
+  uint64_t frame_ptr_addr =
+      GetCoroFramePtrFromHandle(valobj.GetNonSyntheticValue());
+  if (frame_ptr_addr == LLDB_INVALID_ADDRESS)
     return false;
 
-  if (!ptr_sp->GetValueAsUnsigned(0)) {
+  if (frame_ptr_addr == 0) {
     stream << "nullptr";
     return true;
   }
-  if (IsNoopResumeDestroy(ExtractResumeFunction(ptr_sp)) &&
-      IsNoopResumeDestroy(ExtractDestroyFunction(ptr_sp))) {
+
+  lldb::TargetSP target_sp = valobj.GetTargetSP();
+  if (IsNoopResumeDestroy(ExtractResumeFunction(target_sp, frame_ptr_addr)) &&
+      IsNoopResumeDestroy(ExtractDestroyFunction(target_sp, frame_ptr_addr))) {
     stream << "noop_coroutine";
     return true;
   }
 
-  stream.Printf("coro frame = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
+  stream.Printf("coro frame = 0x%" PRIx64, frame_ptr_addr);
   return true;
 }
 
 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     StdlibCoroutineHandleSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp) {
   if (valobj_sp)
     Update();
 }
 
 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     ~StdlibCoroutineHandleSyntheticFrontEnd() = default;
 
 size_t lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     CalculateNumChildren() {
-  if (!m_frame_ptr_sp)
+  if (!m_resume_ptr_sp || !m_destroy_ptr_sp)
     return 0;
 
-  return m_frame_ptr_sp->GetNumChildren();
+  return m_promise_ptr_sp ? 3 : 2;
 }
 
 lldb::ValueObjectSP lldb_private::formatters::
     StdlibCoroutineHandleSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
-  if (!m_frame_ptr_sp)
-    return lldb::ValueObjectSP();
-
-  return m_frame_ptr_sp->GetChildAtIndex(idx, true);
+  switch (idx) {
+  case 0:
+    return m_resume_ptr_sp;
+  case 1:
+    return m_destroy_ptr_sp;
+  case 2:
+    return m_promise_ptr_sp;
+  }
 }
 
 bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     Update() {
-  m_frame_ptr_sp.reset();
+  m_resume_ptr_sp.reset();
+  m_destroy_ptr_sp.reset();
+  m_promise_ptr_sp.reset();
 
-  ValueObjectSP valobj_sp = m_backend.GetSP();
+  ValueObjectSP valobj_sp = m_backend.GetNonSyntheticValue();
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(GetCoroFramePtrFromHandle(m_backend));
-  if (!ptr_sp)
+  uint64_t frame_ptr_addr = GetCoroFramePtrFromHandle(valobj_sp);
+  if (frame_ptr_addr == 0 || frame_ptr_addr == LLDB_INVALID_ADDRESS)
     return false;
 
-  Function *resume_func = ExtractResumeFunction(ptr_sp);
-  Function *destroy_func = ExtractDestroyFunction(ptr_sp);
+  lldb::TargetSP target_sp = m_backend.GetTargetSP();
+  Function *resume_func = ExtractResumeFunction(target_sp, frame_ptr_addr);
+  Function *destroy_func = ExtractDestroyFunction(target_sp, frame_ptr_addr);
 
-  if (IsNoopResumeDestroy(resume_func) && IsNoopResumeDestroy(destroy_func)) {
-    // For `std::noop_coroutine()`, we don't want to display any child nodes.
+  if (IsNoopResumeDestroy(resume_func) && IsNoopResumeDestroy(destroy_func))
     return false;
-  }
+
+  TypeSystemClang *ast_ctx = llvm::dyn_cast_or_null<TypeSystemClang>(
+      valobj_sp->GetCompilerType().GetTypeSystem());
+  if (!ast_ctx)
+    return {};
+
+  // Create the `resume` and `destroy` children
+  auto &exe_ctx = m_backend.GetExecutionContextRef();
+  lldb::ProcessSP process_sp = target_sp->GetProcessSP();
+  auto ptr_size = process_sp->GetAddressByteSize();
+  CompilerType void_type = ast_ctx->GetBasicType(lldb::eBasicTypeVoid);
+  CompilerType coro_func_type = ast_ctx->CreateFunctionType(
+      /*result_type=*/void_type, /*args=*/&void_type, /*num_args=*/1,
+      /*is_variadic=*/false, /*qualifiers=*/0);
+  CompilerType coro_func_ptr_type = coro_func_type.GetPointerType();
+  m_resume_ptr_sp = CreateValueObjectFromAddress(
+      "resume", frame_ptr_addr + 0 * ptr_size, exe_ctx, coro_func_ptr_type);
+  lldbassert(m_resume_ptr_sp);
+  m_destroy_ptr_sp = CreateValueObjectFromAddress(
+      "destroy", frame_ptr_addr + 1 * ptr_size, exe_ctx, coro_func_ptr_type);
+  lldbassert(m_destroy_ptr_sp);
 
   // 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
   if (promise_type.IsVoidType() && destroy_func) {
     if (CompilerType inferred_type = InferPromiseType(*destroy_func)) {
       promise_type = inferred_type;
     }
   }
 
-  // Build the coroutine frame type
-  TypeSystemClang *ast_ctx = llvm::dyn_cast_or_null<TypeSystemClang>(
-      ptr_sp->GetCompilerType().GetTypeSystem());
-  if (!ast_ctx)
-    return {};
-  CompilerType coro_frame_type = GetCoroutineFrameType(*ast_ctx, promise_type);
-
-  m_frame_ptr_sp = ptr_sp->Cast(coro_frame_type.GetPointerType());
+  // Add the `promise` member. We intentionally add `promise` as a pointer type
+  // instead of a value type, and don't automatically dereference this pointer.
+  // We do so to avoid potential very deep recursion in case there is a cycle in
+  // formed between `std::coroutine_handle`s and their promises.
+  uint64_t promise_addr = frame_ptr_addr + 2 * ptr_size;
+  DataExtractor data(&promise_addr, sizeof(promise_addr),
+                     process_sp->GetByteOrder(),
+                     process_sp->GetAddressByteSize());
+  m_promise_ptr_sp = CreateValueObjectFromData("promise", data, exe_ctx,
+                                               promise_type.GetPointerType());
 
   return false;
 }
 
 bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 
 size_t StdlibCoroutineHandleSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {
-  if (!m_frame_ptr_sp)
+  if (!m_resume_ptr_sp || !m_destroy_ptr_sp)
     return UINT32_MAX;
 
-  return m_frame_ptr_sp->GetIndexOfChildWithName(name);
+  if (name == ConstString("resume"))
+    return 0;
+  if (name == ConstString("destroy"))
+    return 1;
+  if (name == ConstString("promise_ptr") && m_promise_ptr_sp)
+    return 2;
+
+  return UINT32_MAX;
 }
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   return (valobj_sp ? new StdlibCoroutineHandleSyntheticFrontEnd(valobj_sp)
                     : nullptr);
 }

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

def do_test(self, stdlib_type):
             # it provides probably a better debugging experience if we display the
             # promise as seen by the program instead of fixing this bug based on
             # the available debug info.
             self.expect_expr("incorrectly_typed_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),
-                    ValueCheck(name="promise", value="-1")
+                    ValueCheck(name="promise", dereference=ValueCheck(value="-1"))
                 ])
 
         # Run until after the `co_yield`
         process = self.process()
         lldbutil.continue_to_source_breakpoint(self, process,
                 '// Break after co_yield', lldb.SBFileSpec("main.cpp", False))
         # We correctly show the updated value inside `prommise.current_value`.
         self.expect_expr("gen.hdl",