[Lldb-commits] [lldb] 8aa3137 - [LLDB] Do not dereference promise pointer in `coroutine_handle` pretty printer
Adrian Vogelsgesang via lldb-commits
lldb-commits at lists.llvm.org
Tue Jan 31 07:47:27 PST 2023
Author: Adrian Vogelsgesang
Date: 2023-01-31T07:40:31-08:00
New Revision: 8aa313755118bf43c6042fb316b6c243b2c59be2
URL: https://github.com/llvm/llvm-project/commit/8aa313755118bf43c6042fb316b6c243b2c59be2
DIFF: https://github.com/llvm/llvm-project/commit/8aa313755118bf43c6042fb316b6c243b2c59be2.diff
LOG: [LLDB] Do not dereference promise pointer in `coroutine_handle` pretty printer
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.
Differential Revision: https://reviews.llvm.org/D132815
Added:
Modified:
lldb/packages/Python/lldbsuite/test/lldbtest.py
lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp
lldb/source/Plugins/Language/CPlusPlus/Coroutines.h
lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py
Removed:
################################################################################
diff --git a/lldb/packages/Python/lldbsuite/test/lldbtest.py b/lldb/packages/Python/lldbsuite/test/lldbtest.py
index 97fe14e769cdd..e2c076132fc63 100644
--- a/lldb/packages/Python/lldbsuite/test/lldbtest.py
+++ b/lldb/packages/Python/lldbsuite/test/lldbtest.py
@@ -247,7 +247,7 @@ def which(program):
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.
@@ -262,12 +262,15 @@ def __init__(self, name=None, value=None, type=None, summary=None,
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
+ `Dereference` 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):
"""
@@ -309,6 +312,9 @@ def check_value(self, test_base, val, error_msg=None):
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
diff --git a/lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp b/lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp
index bd9ff99db67b8..bd428a812531a 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/Coroutines.cpp
@@ -17,38 +17,37 @@ using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::formatters;
-static ValueObjectSP GetCoroFramePtrFromHandle(ValueObject &valobj) {
- ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
+static lldb::addr_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 *ExtractDestroyFunction(ValueObjectSP &frame_ptr_sp) {
- 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 *ExtractDestroyFunction(lldb::TargetSP target_sp,
+ lldb::addr_t frame_ptr_addr) {
+ lldb::ProcessSP process_sp = target_sp->GetProcessSP();
+ auto ptr_size = process_sp->GetAddressByteSize();
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);
@@ -59,12 +58,7 @@ static Function *ExtractDestroyFunction(ValueObjectSP &frame_ptr_sp) {
if (!target_sp->ResolveLoadAddress(destroy_func_addr, destroy_func_address))
return nullptr;
- Function *destroy_func =
- destroy_func_address.CalculateSymbolContextFunction();
- if (!destroy_func)
- return nullptr;
-
- return destroy_func;
+ return destroy_func_address.CalculateSymbolContextFunction();
}
static CompilerType InferPromiseType(Function &destroy_func) {
@@ -85,37 +79,19 @@ static CompilerType InferPromiseType(Function &destroy_func) {
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)
+ lldb::addr_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";
} else {
- stream.Printf("coro frame = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
+ stream.Printf("coro frame = 0x%" PRIx64, frame_ptr_addr);
}
+
return true;
}
@@ -132,32 +108,61 @@ lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
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;
+ }
+ return lldb::ValueObjectSP();
}
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)
+ lldb::addr_t frame_ptr_addr = GetCoroFramePtrFromHandle(valobj_sp);
+ if (frame_ptr_addr == 0 || frame_ptr_addr == LLDB_INVALID_ADDRESS)
+ return false;
+
+ auto ts = valobj_sp->GetCompilerType().GetTypeSystem();
+ auto ast_ctx = ts.dyn_cast_or_null<TypeSystemClang>();
+ if (!ast_ctx)
return false;
+ // Create the `resume` and `destroy` children.
+ lldb::TargetSP target_sp = m_backend.GetTargetSP();
+ 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));
@@ -165,12 +170,9 @@ bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
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 (Function *destroy_func =
+ ExtractDestroyFunction(target_sp, frame_ptr_addr)) {
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);
@@ -178,10 +180,22 @@ bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
}
}
- // Build the coroutine frame type
- CompilerType coro_frame_type = GetCoroutineFrameType(*ast_ctx, promise_type);
+ // If we don't know the promise type, we don't display the `promise` member.
+ // `CreateValueObjectFromAddress` below would fail for `void` types.
+ if (promise_type.IsVoidType()) {
+ return false;
+ }
- 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
+ // formed between `std::coroutine_handle`s and their promises.
+ lldb::ValueObjectSP promise = CreateValueObjectFromAddress(
+ "promise", frame_ptr_addr + 2 * ptr_size, exe_ctx, promise_type);
+ Status error;
+ lldb::ValueObjectSP promisePtr = promise->AddressOf(error);
+ if (error.Success())
+ m_promise_ptr_sp = promisePtr->Clone(ConstString("promise"));
return false;
}
@@ -193,10 +207,17 @@ bool lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEnd::
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 *
diff --git a/lldb/source/Plugins/Language/CPlusPlus/Coroutines.h b/lldb/source/Plugins/Language/CPlusPlus/Coroutines.h
index c052bd23f4ca9..e2e640ab48430 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/Coroutines.h
+++ b/lldb/source/Plugins/Language/CPlusPlus/Coroutines.h
@@ -47,7 +47,9 @@ class StdlibCoroutineHandleSyntheticFrontEnd
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;
std::unique_ptr<lldb_private::ClangASTImporter> m_ast_importer;
};
diff --git a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py
index 44e5e6451c10d..4edf3eb1780d6 100644
--- a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py
+++ b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/coroutine_handle/TestCoroutineHandle.py
@@ -61,7 +61,7 @@ def do_test(self, stdlib_type):
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`
More information about the lldb-commits
mailing list