Author: Jonas Devlieghere Date: 2025-02-17T15:44:41-08:00 New Revision: a3dc77c00a012bb613cb08e669dab4fadf88e935
URL: https://github.com/llvm/llvm-project/commit/a3dc77c00a012bb613cb08e669dab4fadf88e935 DIFF: https://github.com/llvm/llvm-project/commit/a3dc77c00a012bb613cb08e669dab4fadf88e935.diff LOG: [lldb] Support stepping through C++ thunks (#127419) This PR fixes LLDB stepping out, rather than stepping through a C++ thunk. The implementation is based on, and upstreams, the support for runtime thunks in the Swift fork. Fixes #43413 Added: lldb/test/API/lang/cpp/thunk/Makefile lldb/test/API/lang/cpp/thunk/TestThunk.py lldb/test/API/lang/cpp/thunk/main.cpp Modified: lldb/include/lldb/Target/LanguageRuntime.h lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h lldb/source/Target/ThreadPlanShouldStopHere.cpp Removed: ################################################################################ diff --git a/lldb/include/lldb/Target/LanguageRuntime.h b/lldb/include/lldb/Target/LanguageRuntime.h index f9ae2dc589632..7e4c11df0da7f 100644 --- a/lldb/include/lldb/Target/LanguageRuntime.h +++ b/lldb/include/lldb/Target/LanguageRuntime.h @@ -201,6 +201,8 @@ class LanguageRuntime : public Runtime, public PluginInterface { return false; } + virtual bool IsSymbolARuntimeThunk(const Symbol &symbol) { return false; } + // Given the name of a runtime symbol (e.g. in Objective-C, an ivar offset // symbol), try to determine from the runtime what the value of that symbol // would be. Useful when the underlying binary is stripped. diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp index 42fa54634841c..21a5ebe53073a 100644 --- a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp @@ -476,3 +476,14 @@ CPPLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread, return ret_plan_sp; } + +bool CPPLanguageRuntime::IsSymbolARuntimeThunk(const Symbol &symbol) { + llvm::StringRef mangled_name = + symbol.GetMangled().GetMangledName().GetStringRef(); + // Virtual function overriding from a non-virtual base use a "Th" prefix. + // Virtual function overriding from a virtual base must use a "Tv" prefix. + // Virtual function overriding thunks with covariant returns use a "Tc" + // prefix. + return mangled_name.starts_with("_ZTh") || mangled_name.starts_with("_ZTv") || + mangled_name.starts_with("_ZTc"); +} diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h index 57cfe28245808..05639e9798917 100644 --- a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h @@ -78,6 +78,9 @@ class CPPLanguageRuntime : public LanguageRuntime { bool stop_others) override; bool IsAllowedRuntimeValue(ConstString name) override; + + bool IsSymbolARuntimeThunk(const Symbol &symbol) override; + protected: // Classes that inherit from CPPLanguageRuntime can see and modify these CPPLanguageRuntime(Process *process); diff --git a/lldb/source/Target/ThreadPlanShouldStopHere.cpp b/lldb/source/Target/ThreadPlanShouldStopHere.cpp index e72f8d8f51a20..fa6bc08a9914d 100644 --- a/lldb/source/Target/ThreadPlanShouldStopHere.cpp +++ b/lldb/source/Target/ThreadPlanShouldStopHere.cpp @@ -8,6 +8,7 @@ #include "lldb/Target/ThreadPlanShouldStopHere.h" #include "lldb/Symbol/Symbol.h" +#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/RegisterContext.h" #include "lldb/Target/Thread.h" #include "lldb/Utility/LLDBLog.h" @@ -76,6 +77,19 @@ bool ThreadPlanShouldStopHere::DefaultShouldStopHereCallback( } } + // Check whether the frame we are in is a language runtime thunk, only for + // step out: + if (operation == eFrameCompareOlder) { + if (Symbol *symbol = frame->GetSymbolContext(eSymbolContextSymbol).symbol) { + ProcessSP process_sp(current_plan->GetThread().GetProcess()); + for (auto *runtime : process_sp->GetLanguageRuntimes()) { + if (runtime->IsSymbolARuntimeThunk(*symbol)) { + should_stop_here = false; + break; + } + } + } + } // Always avoid code with line number 0. // FIXME: At present the ShouldStop and the StepFromHere calculate this // independently. If this ever @@ -109,18 +123,35 @@ ThreadPlanSP ThreadPlanShouldStopHere::DefaultStepFromHereCallback( if (sc.line_entry.line == 0) { AddressRange range = sc.line_entry.range; - - // If the whole function is marked line 0 just step out, that's easier & - // faster than continuing to step through it. bool just_step_out = false; - if (sc.symbol && sc.symbol->ValueIsAddress()) { - Address symbol_end = sc.symbol->GetAddress(); - symbol_end.Slide(sc.symbol->GetByteSize() - 1); - if (range.ContainsFileAddress(sc.symbol->GetAddress()) && - range.ContainsFileAddress(symbol_end)) { - LLDB_LOGF(log, "Stopped in a function with only line 0 lines, just " - "stepping out."); - just_step_out = true; + if (sc.symbol) { + ProcessSP process_sp(current_plan->GetThread().GetProcess()); + + // If this is a runtime thunk, step through it, rather than stepping out + // because it's marked line 0. + bool is_thunk = false; + for (auto *runtime : process_sp->GetLanguageRuntimes()) { + if (runtime->IsSymbolARuntimeThunk(*sc.symbol)) { + LLDB_LOGF(log, "In runtime thunk %s - stepping out.", + sc.symbol->GetName().GetCString()); + is_thunk = true; + break; + } + } + + // If the whole function is marked line 0 just step out, that's easier & + // faster than continuing to step through it. + // FIXME: This assumes that the function is a single line range. It could + // be a series of contiguous line 0 ranges. Check for that too. + if (!is_thunk && sc.symbol->ValueIsAddress()) { + Address symbol_end = sc.symbol->GetAddress(); + symbol_end.Slide(sc.symbol->GetByteSize() - 1); + if (range.ContainsFileAddress(sc.symbol->GetAddress()) && + range.ContainsFileAddress(symbol_end)) { + LLDB_LOGF(log, "Stopped in a function with only line 0 lines, just " + "stepping out."); + just_step_out = true; + } } } if (!just_step_out) { diff --git a/lldb/test/API/lang/cpp/thunk/Makefile b/lldb/test/API/lang/cpp/thunk/Makefile new file mode 100644 index 0000000000000..99998b20bcb05 --- /dev/null +++ b/lldb/test/API/lang/cpp/thunk/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/lldb/test/API/lang/cpp/thunk/TestThunk.py b/lldb/test/API/lang/cpp/thunk/TestThunk.py new file mode 100644 index 0000000000000..ceb16263648d6 --- /dev/null +++ b/lldb/test/API/lang/cpp/thunk/TestThunk.py @@ -0,0 +1,46 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class ThunkTest(TestBase): + def test_step_through_thunk(self): + self.build() + lldbutil.run_to_name_breakpoint(self, "testit") + + # Make sure we step through the thunk into Derived1::doit + self.expect( + "step", + STEP_IN_SUCCEEDED, + substrs=["stop reason = step in", "Derived1::doit"], + ) + + self.runCmd("continue") + + self.expect( + "step", + STEP_IN_SUCCEEDED, + substrs=["stop reason = step in", "Derived2::doit"], + ) + + def test_step_out_thunk(self): + self.build() + lldbutil.run_to_name_breakpoint(self, "testit_debug") + + # Make sure we step out of the thunk and end up in testit_debug. + source = "main.cpp" + line = line_number(source, "// Step here") + self.expect( + "step", + STEP_IN_SUCCEEDED, + substrs=["stop reason = step in", "{}:{}".format(source, line)], + ) + + self.runCmd("continue") + + self.expect( + "step", + STEP_IN_SUCCEEDED, + substrs=["stop reason = step in", "Derived2::doit_debug"], + ) diff --git a/lldb/test/API/lang/cpp/thunk/main.cpp b/lldb/test/API/lang/cpp/thunk/main.cpp new file mode 100644 index 0000000000000..82d17b1350093 --- /dev/null +++ b/lldb/test/API/lang/cpp/thunk/main.cpp @@ -0,0 +1,48 @@ +#include <stdio.h> + +class Base1 { +public: + virtual ~Base1() {} +}; + +class Base2 { +public: + virtual void doit() = 0; + virtual void doit_debug() = 0; +}; + +Base2 *b; + +class Derived1 : public Base1, public Base2 { +public: + virtual void doit() { printf("Derived1\n"); } + virtual void __attribute__((nodebug)) doit_debug() { + printf("Derived1 (no debug)\n"); + } +}; + +class Derived2 : public Base2 { +public: + virtual void doit() { printf("Derived2\n"); } + virtual void doit_debug() { printf("Derived2 (debug)\n"); } +}; + +void testit() { b->doit(); } + +void testit_debug() { + b->doit_debug(); + printf("This is where I should step out to with nodebug.\n"); // Step here +} + +int main() { + + b = new Derived1(); + testit(); + testit_debug(); + + b = new Derived2(); + testit(); + testit_debug(); + + return 0; +} _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
