[LanguageRuntime] Move CPPLanguageRuntime into a plugin

[xiaobai]

Summary

This seems better suited to be in a plugin.

[JDevlieghere]

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

What's the benefit of making this a separate plugin, as compared to making it part of Plugins/Language/CPlusPlus?

[jingham]

My model for this was that there was a CPPLanguageRuntime.cpp that contains everything you can implement about the CPP runtime that is independent of any particular implementation of the CPP language runtime, and then a plugin instance (in this case the ItaniumABILanguageRuntime) that contains all the bits that are specific to a particular implementation. Then putting the CPPLanguageRuntime.cpp in Target lets you know that this has to only contain the generic parts of the runtime behavior. That still seems to me a useful distinction.

[xiaobai]

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

I view LanguageRuntimes as distinct from Languages and thus I think they should go into their own plugins. However, I'm not against moving this to Plugins/Language/CPlusPlus if you think it would make more sense to do so for another reason (e.g. less plugins overall?)

[labath]

What is the indented relationship between CPPLanguage and CPPLanguageRuntime plugins (and generally between any Language and its LanguageRuntime)? Right now you're having the CPPLanguage depend on the CPPLanguageRuntime plugin. There is no reverse dependency, so this may be fine, if that's how we intend things to be. However, it's not clear to me whether that's the right way to organize things. Intuitively, I'd expect the LanguageRuntime to depend on Language, and not the other way around...

[compnerd]

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

We do need the abstraction since there are multiple C++ runtimes: c++, stdc++, MSVCPRT, stlport, etc. Each one is slightly different. Furthermore, libstdc++ supported the GNU and Solaris ABIs, libc++ only does itanium, MSVCPRT only does MSVC ABI. So, we need to have some layer to differentiate between the various ABIs and just general C++ language support.

[labath]

In D64599#1581598, @jingham wrote:

My model for this was that there was a CPPLanguageRuntime.cpp that contains everything you can implement about the CPP runtime that is independent of any particular implementation of the CPP language runtime, and then a plugin instance (in this case the ItaniumABILanguageRuntime) that contains all the bits that are specific to a particular implementation. Then putting the CPPLanguageRuntime.cpp in Target lets you know that this has to only contain the generic parts of the runtime behavior. That still seems to me a useful distinction.

I think that's fine, but it does not conflict the idea of the generic parts of a cpp language runtime being a plugin also. This way the generic parts of lldb would be truly language agnostic. Then if anything wants to work with a c++ runtime, but it does not care which one, it can use CPPLanguageRuntime. And if you need a very specific runtime, you go for the Itanium thingy.

[labath]

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

That is true. However, I'm not sure whether the current boundary actually makes sense. E.g. the c++ language plugin implements pretty printers for both libc++ and libstdc++.

[jingham]

In D64599#1581604, @labath wrote:

What is the indented relationship between CPPLanguage and CPPLanguageRuntime plugins (and generally between any Language and its LanguageRuntime)? Right now you're having the CPPLanguage depend on the CPPLanguageRuntime plugin. There is no reverse dependency, so this may be fine, if that's how we intend things to be. However, it's not clear to me whether that's the right way to organize things. Intuitively, I'd expect the LanguageRuntime to depend on Language, and not the other way around...

The nominal distinction is that the Language files contain what you can know about or need to do with a given language without having a process and thus a live runtime to query. The LanguageRuntimes are supposed to be about what you can gather from the actual runtime, or what you need to do to handle things like "stepping into steps across ObjC method dispatch functions" or "stepping into std::function steps in to the target function". Given this distinction you'd actually expect the two to be independent of one another, but then it turns out that in both ObjC and Swift, you can't actually know the sizes of objects, or the offsets of ivar members until you have a running process. So things you'd think the Language would know actually require the LanguageRuntime...

[xiaobai]

In D64599#1581620, @labath wrote:

In D64599#1581598, @jingham wrote:

My model for this was that there was a CPPLanguageRuntime.cpp that contains everything you can implement about the CPP runtime that is independent of any particular implementation of the CPP language runtime, and then a plugin instance (in this case the ItaniumABILanguageRuntime) that contains all the bits that are specific to a particular implementation. Then putting the CPPLanguageRuntime.cpp in Target lets you know that this has to only contain the generic parts of the runtime behavior. That still seems to me a useful distinction.

I think that's fine, but it does not conflict the idea of the generic parts of a cpp language runtime being a plugin also. This way the generic parts of lldb would be truly language agnostic. Then if anything wants to work with a c++ runtime, but it does not care which one, it can use CPPLanguageRuntime. And if you need a very specific runtime, you go for the Itanium thingy.

+1

In D64599#1581661, @jingham wrote:

In D64599#1581604, @labath wrote:

What is the indented relationship between CPPLanguage and CPPLanguageRuntime plugins (and generally between any Language and its LanguageRuntime)? Right now you're having the CPPLanguage depend on the CPPLanguageRuntime plugin. There is no reverse dependency, so this may be fine, if that's how we intend things to be. However, it's not clear to me whether that's the right way to organize things. Intuitively, I'd expect the LanguageRuntime to depend on Language, and not the other way around...

The nominal distinction is that the Language files contain what you can know about or need to do with a given language without having a process and thus a live runtime to query. The LanguageRuntimes are supposed to be about what you can gather from the actual runtime, or what you need to do to handle things like "stepping into steps across ObjC method dispatch functions" or "stepping into std::function steps in to the target function". Given this distinction you'd actually expect the two to be independent of one another, but then it turns out that in both ObjC and Swift, you can't actually know the sizes of objects, or the offsets of ivar members until you have a running process. So things you'd think the Language would know actually require the LanguageRuntime...

I also think that Language depending on LanguageRuntime makes sense. It seems to me that in order for the Language to be able to answer questions about implementation-defined features, it must ask the language runtime for help.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

Given that those are formatters specific to the libc++ and libstdc++ implementations, I think it would make sense that those are a part of the C++ language runtime plugin(s).

[jingham]

In D64599#1581620, @labath wrote:

In D64599#1581598, @jingham wrote:

My model for this was that there was a CPPLanguageRuntime.cpp that contains everything you can implement about the CPP runtime that is independent of any particular implementation of the CPP language runtime, and then a plugin instance (in this case the ItaniumABILanguageRuntime) that contains all the bits that are specific to a particular implementation. Then putting the CPPLanguageRuntime.cpp in Target lets you know that this has to only contain the generic parts of the runtime behavior. That still seems to me a useful distinction.

I think that's fine, but it does not conflict the idea of the generic parts of a cpp language runtime being a plugin also. This way the generic parts of lldb would be truly language agnostic. Then if anything wants to work with a c++ runtime, but it does not care which one, it can use CPPLanguageRuntime. And if you need a very specific runtime, you go for the Itanium thingy.

I see where you are going...

Im my head, the plugin hierarchy for runtimes goes LanguageRuntime -> CPPLanguageRuntime -> ItaniumABILanguageRuntime. I've been calling all those "parts of the plugin for language runtimes". LanguageRuntime is the generic plugin interface, and currently CPPLanguageRuntime (and ObjCLanguageRuntime...) are also being treated as "generic parts of the LanguageRuntime plugin". Then ItaniumABILanguageRuntime.h is an instance of the plugin. Then the generic plugin interface files live out of the Plugin hierarchy and are free game, and the instances are in Plugins and should not be included from generic code.

Anyway, if you can make all the generic parts of lldb not depend on the language specific - but still abstract - part of the plugin, that would be fine. Then just LanguageRuntime.h would live in Target, and CPPLanguageRuntime would live in Plugins/Language

CPPLanguageRuntime is really only used in other plugins, so it's easy. ObjCLanguageRuntime has a few more uses in generic code, and the SwiftLanguageRuntime has some more uses in generic code (included in 16 generic files). That corresponds to the fact that ObjC and the Swift are systems that are increasingly more dependent on their runtimes in order for the debugger to comprehend them. Presumably we could fix this by adding some more abstract methods to LanguageRuntime, though I'd have to do some more investigation to see how awkward that would be, particularly for swift...

It doesn't seem to me useful to move CPPLanguageRuntime to the instance-specific part of LanguageRuntime, if we can't also do that for ObjC and Swift. That's just confusing. But if as a proof of concept you can get ObjCLanguageRuntime.h out of generic code, then presumably we can also do that for Swift, and the project seems worthwhile.

[jingham]

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

So the problem with that is that formatters don't actually require a live process to be useful. They can be used to view static data in a not-running process. But LanguageRuntimes currently only come from a process. So to move the formatters to the LanguageRuntime - which does make some sense - you're going to have to change the LanguageRuntime to do some things for a target with no process and the more things when the Process gets a target. That's not a bad change, BTW.

Anyway, that's why the formatters are a little out-of-place.

[xiaobai]

In D64599#1581718, @jingham wrote:

Anyway, if you can make all the generic parts of lldb not depend on the language specific - but still abstract - part of the plugin, that would be fine. Then just LanguageRuntime.h would live in Target, and CPPLanguageRuntime would live in Plugins/Language

This is exactly where I'm trying to take things and it's why I've been shuffling things around and making things more generic.

CPPLanguageRuntime is really only used in other plugins, so it's easy. ObjCLanguageRuntime has a few more uses in generic code, and the SwiftLanguageRuntime has some more uses in generic code (included in 16 generic files). That corresponds to the fact that ObjC and the Swift are systems that are increasingly more dependent on their runtimes in order for the debugger to comprehend them. Presumably we could fix this by adding some more abstract methods to LanguageRuntime, though I'd have to do some more investigation to see how awkward that would be, particularly for swift...

ObjCLanguageRuntime has 3 more uses in "base lldb" (non-plugin libraries) that I'm trying to get rid of.

• Core/ValueObject.cpp: D64159
• Expression/IRDynamicChecks.cpp: D64591
• Symbol/ClangASTContext.cpp: I don't plan on removing this one. Instead, I want to move ClangASTContext out of Symbol into a plugin.

After the first 2 are moved out, I intend on moving ObjCLanguageRuntime out as well. I'm also working on SwiftLanguageRuntime in the swift-lldb repository, although a little more slowly as I wanted to get C++ and ObjC done first.

Also, as an aside, I intend on trying to get swift debugging support into llvm.org at some point. I don't think llvm.org is in a place where that can be done cleanly, and I think swift-lldb's swift-specific bits need to be pulled into plugins before it becomes a reasonable endeavor. But that's the direction I want to head in. I feel similarly about Rust support. :)

It doesn't seem to me useful to move CPPLanguageRuntime to the instance-specific part of LanguageRuntime, if we can't also do that for ObjC and Swift. That's just confusing. But if as a proof of concept you can get ObjCLanguageRuntime.h out of generic code, then presumably we can also do that for Swift, and the project seems worthwhile.

I uploaded this first to get some feedback and introduce the idea of moving CPPLanguageRuntime, ObjCLanguageRuntime, and SwiftLanguageRuntime. I figured I'd get any issues out of the way with the easiest one.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

55 ↗

(On Diff #209331)

Right this makes sense to me. I think we could figure something out here, as I've dealt with needing access to LanguageRuntimes without a process. I think something can be done, but that can be left for another time I think.

[jingham]

Okay... Provided we can come up with not too torturous ways to get the ObjC and Swift support out of generic-code, it seems okay to do this as a first step. I just don't want to end up in the state where we have ObjCLanguageRuntime as generic but CPPLanguageRuntime is not.

lldb/trunk/include/lldb/Target/CPPLanguageRuntime.h

-//===-- CPPLanguageRuntime.h
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_CPPLanguageRuntime_h_
-#define liblldb_CPPLanguageRuntime_h_
-
-#include <vector>
-#include "lldb/Core/PluginInterface.h"
-#include "lldb/Target/LanguageRuntime.h"
-#include "lldb/lldb-private.h"
-
-namespace lldb_private {
-
-class CPPLanguageRuntime : public LanguageRuntime {
-public:
-  enum class LibCppStdFunctionCallableCase {
-    Lambda = 0,
-    CallableObject,
-    FreeOrMemberFunction,
-    Invalid
-  };
-
-  struct LibCppStdFunctionCallableInfo {
-    Symbol callable_symbol;
-    Address callable_address;
-    LineEntry callable_line_entry;
-    lldb::addr_t member__f_pointer_value = 0u;
-    LibCppStdFunctionCallableCase callable_case =
-        LibCppStdFunctionCallableCase::Invalid;
-  };
-
-  LibCppStdFunctionCallableInfo
-  FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp);
-
-  ~CPPLanguageRuntime() override;
-
-  static char ID;
-
-  bool isA(const void *ClassID) const override {
-    return ClassID == &ID || LanguageRuntime::isA(ClassID);
-  }
-
-  static bool classof(const LanguageRuntime *runtime) {
-    return runtime->isA(&ID);
-  }
-
-  lldb::LanguageType GetLanguageType() const override {
-    return lldb::eLanguageTypeC_plus_plus;
-  }
-
-  static CPPLanguageRuntime *Get(Process &process) {
-    return llvm::cast_or_null<CPPLanguageRuntime>(
-        process.GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus));
-  }
-
-  bool GetObjectDescription(Stream &str, ValueObject &object) override;
-
-  bool GetObjectDescription(Stream &str, Value &value,
-                            ExecutionContextScope *exe_scope) override;
-
-  /// Obtain a ThreadPlan to get us into C++ constructs such as std::function.
-  ///
-  /// \param[in] thread
-  ///     Curent thrad of execution.
-  ///
-  /// \param[in] stop_others
-  ///     True if other threads should pause during execution.
-  ///
-  /// \return
-  ///      A ThreadPlan Shared pointer
-  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
-                                                  bool stop_others) override;
-
-  bool IsWhitelistedRuntimeValue(ConstString name) override;
-protected:
-  // Classes that inherit from CPPLanguageRuntime can see and modify these
-  CPPLanguageRuntime(Process *process);
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(CPPLanguageRuntime);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_CPPLanguageRuntime_h_

lldb/trunk/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

LINK_LIBS
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginCPlusPlusLanguage
+    lldbPluginCPPRuntime
   LINK_COMPONENTS
     Core
     ExecutionEngine
     ipo
     MCJIT
     Support
   )

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
+#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
 namespace {
 const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 } // anonymous namespace

lldb/trunk/source/Plugins/Language/CPlusPlus/CMakeLists.txt

add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   LINK_LIBS
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginClangCommon
+    lldbPluginCPPRuntime
 
   LINK_COMPONENTS
     Support
 )

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.cpp

 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/VectorIterator.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
+#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 bool lldb_private::formatters::LibcxxOptionalSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/CMakeLists.txt

+add_lldb_library(lldbPluginCPPRuntime PLUGIN
+  CPPLanguageRuntime.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbSymbol
+    lldbTarget
+)
+
 add_subdirectory(ItaniumABI)
 #add_subdirectory(MicrosoftABI)

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h

+//===-- CPPLanguageRuntime.h
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_CPPLanguageRuntime_h_
+#define liblldb_CPPLanguageRuntime_h_
+
+#include <vector>
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Target/LanguageRuntime.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class CPPLanguageRuntime : public LanguageRuntime {
+public:
+  enum class LibCppStdFunctionCallableCase {
+    Lambda = 0,
+    CallableObject,
+    FreeOrMemberFunction,
+    Invalid
+  };
+
+  struct LibCppStdFunctionCallableInfo {
+    Symbol callable_symbol;
+    Address callable_address;
+    LineEntry callable_line_entry;
+    lldb::addr_t member__f_pointer_value = 0u;
+    LibCppStdFunctionCallableCase callable_case =
+        LibCppStdFunctionCallableCase::Invalid;
+  };
+
+  LibCppStdFunctionCallableInfo
+  FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp);
+
+  ~CPPLanguageRuntime() override;
+
+  static char ID;
+
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || LanguageRuntime::isA(ClassID);
+  }
+
+  static bool classof(const LanguageRuntime *runtime) {
+    return runtime->isA(&ID);
+  }
+
+  lldb::LanguageType GetLanguageType() const override {
+    return lldb::eLanguageTypeC_plus_plus;
+  }
+
+  static CPPLanguageRuntime *Get(Process &process) {
+    return llvm::cast_or_null<CPPLanguageRuntime>(
+        process.GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus));
+  }
+
+  bool GetObjectDescription(Stream &str, ValueObject &object) override;
+
+  bool GetObjectDescription(Stream &str, Value &value,
+                            ExecutionContextScope *exe_scope) override;
+
+  /// Obtain a ThreadPlan to get us into C++ constructs such as std::function.
+  ///
+  /// \param[in] thread
+  ///     Curent thrad of execution.
+  ///
+  /// \param[in] stop_others
+  ///     True if other threads should pause during execution.
+  ///
+  /// \return
+  ///      A ThreadPlan Shared pointer
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
+                                                  bool stop_others) override;
+
+  bool IsWhitelistedRuntimeValue(ConstString name) override;
+protected:
+  // Classes that inherit from CPPLanguageRuntime can see and modify these
+  CPPLanguageRuntime(Process *process);
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(CPPLanguageRuntime);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_CPPLanguageRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

+//===-- CPPLanguageRuntime.cpp
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <string.h>
+
+#include <memory>
+
+#include "CPPLanguageRuntime.h"
+
+#include "llvm/ADT/StringRef.h"
+
+#include "lldb/Symbol/Block.h"
+#include "lldb/Symbol/Variable.h"
+#include "lldb/Symbol/VariableList.h"
+
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/UniqueCStringMap.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/ThreadPlanRunToAddress.h"
+#include "lldb/Target/ThreadPlanStepInRange.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static ConstString g_this = ConstString("this");
+
+char CPPLanguageRuntime::ID = 0;
+
+// Destructor
+CPPLanguageRuntime::~CPPLanguageRuntime() {}
+
+CPPLanguageRuntime::CPPLanguageRuntime(Process *process)
+    : LanguageRuntime(process) {}
+
+bool CPPLanguageRuntime::IsWhitelistedRuntimeValue(ConstString name) {
+  return name == g_this;
+}
+
+bool CPPLanguageRuntime::GetObjectDescription(Stream &str,
+                                              ValueObject &object) {
+  // C++ has no generic way to do this.
+  return false;
+}
+
+bool CPPLanguageRuntime::GetObjectDescription(
+    Stream &str, Value &value, ExecutionContextScope *exe_scope) {
+  // C++ has no generic way to do this.
+  return false;
+}
+
+CPPLanguageRuntime::LibCppStdFunctionCallableInfo
+CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
+    lldb::ValueObjectSP &valobj_sp) {
+  LibCppStdFunctionCallableInfo optional_info;
+
+  if (!valobj_sp)
+    return optional_info;
+
+  // Member __f_ has type __base*, the contents of which will hold:
+  // 1) a vtable entry which may hold type information needed to discover the
+  //    lambda being called
+  // 2) possibly hold a pointer to the callable object
+  // e.g.
+  //
+  // (lldb) frame var -R  f_display
+  // (std::__1::function<void (int)>) f_display = {
+  //  __buf_ = {
+  //  …
+  // }
+  //  __f_ = 0x00007ffeefbffa00
+  // }
+  // (lldb) memory read -fA 0x00007ffeefbffa00
+  // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ...
+  // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ...
+  //
+  // We will be handling five cases below, std::function is wrapping:
+  //
+  // 1) a lambda we know at compile time. We will obtain the name of the lambda
+  //    from the first template pameter from __func's vtable. We will look up
+  //    the lambda's operator()() and obtain the line table entry.
+  // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method
+  //    will be stored after the vtable. We will obtain the lambdas name from
+  //    this entry and lookup operator()() and obtain the line table entry.
+  // 3) a callable object via operator()(). We will obtain the name of the
+  //    object from the first template parameter from __func's vtable. We will
+  //    look up the objectc operator()() and obtain the line table entry.
+  // 4) a member function. A pointer to the function will stored after the
+  //    we will obtain the name from this pointer.
+  // 5) a free function. A pointer to the function will stored after the vtable
+  //    we will obtain the name from this pointer.
+  ValueObjectSP member__f_(
+      valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
+
+  if (member__f_) {
+    ValueObjectSP sub_member__f_(
+       member__f_->GetChildMemberWithName(ConstString("__f_"), true));
+
+    if (sub_member__f_)
+        member__f_ = sub_member__f_;
+  }
+
+  lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0);
+
+  optional_info.member__f_pointer_value = member__f_pointer_value;
+
+  ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
+  Process *process = exe_ctx.GetProcessPtr();
+
+  if (process == nullptr)
+    return optional_info;
+
+  uint32_t address_size = process->GetAddressByteSize();
+  Status status;
+
+  // First item pointed to by __f_ should be the pointer to the vtable for
+  // a __base object.
+  lldb::addr_t vtable_address =
+      process->ReadPointerFromMemory(member__f_pointer_value, status);
+
+  if (status.Fail())
+    return optional_info;
+
+  lldb::addr_t address_after_vtable = member__f_pointer_value + address_size;
+  // As commened above we may not have a function pointer but if we do we will
+  // need it.
+  lldb::addr_t possible_function_address =
+      process->ReadPointerFromMemory(address_after_vtable, status);
+
+  if (status.Fail())
+    return optional_info;
+
+  Target &target = process->GetTarget();
+
+  if (target.GetSectionLoadList().IsEmpty())
+    return optional_info;
+
+  Address vtable_addr_resolved;
+  SymbolContext sc;
+  Symbol *symbol;
+
+  if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address,
+                                                      vtable_addr_resolved))
+    return optional_info;
+
+  target.GetImages().ResolveSymbolContextForAddress(
+      vtable_addr_resolved, eSymbolContextEverything, sc);
+  symbol = sc.symbol;
+
+  if (symbol == nullptr)
+    return optional_info;
+
+  llvm::StringRef vtable_name(symbol->GetName().GetCString());
+  bool found_expected_start_string =
+      vtable_name.startswith("vtable for std::__1::__function::__func<");
+
+  if (!found_expected_start_string)
+    return optional_info;
+
+  // Given case 1 or 3 we have a vtable name, we are want to extract the first
+  // template parameter
+  //
+  //  ... __func<main::$_0, std::__1::allocator<main::$_0> ...
+  //             ^^^^^^^^^
+  //
+  // We do this by find the first < and , and extracting in between.
+  //
+  // This covers the case of the lambda known at compile time.
+  size_t first_open_angle_bracket = vtable_name.find('<') + 1;
+  size_t first_comma = vtable_name.find(',');
+
+  llvm::StringRef first_template_parameter =
+      vtable_name.slice(first_open_angle_bracket, first_comma);
+
+  Address function_address_resolved;
+
+  // Setup for cases 2, 4 and 5 we have a pointer to a function after the
+  // vtable. We will use a process of elimination to drop through each case
+  // and obtain the data we need.
+  if (target.GetSectionLoadList().ResolveLoadAddress(
+          possible_function_address, function_address_resolved)) {
+    target.GetImages().ResolveSymbolContextForAddress(
+        function_address_resolved, eSymbolContextEverything, sc);
+    symbol = sc.symbol;
+  }
+
+  auto get_name = [&first_template_parameter, &symbol]() {
+    // Given case 1:
+    //
+    //    main::$_0
+    //
+    // we want to append ::operator()()
+    if (first_template_parameter.contains("$_"))
+      return llvm::Regex::escape(first_template_parameter.str()) +
+             R"(::operator\(\)\(.*\))";
+
+    if (symbol != nullptr &&
+        symbol->GetName().GetStringRef().contains("__invoke")) {
+
+      llvm::StringRef symbol_name = symbol->GetName().GetStringRef();
+      size_t pos2 = symbol_name.find_last_of(':');
+
+      // Given case 2:
+      //
+      //    main::$_1::__invoke(...)
+      //
+      // We want to slice off __invoke(...) and append operator()()
+      std::string lambda_operator =
+          llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) +
+          R"(operator\(\)\(.*\))";
+
+      return lambda_operator;
+    }
+
+    // Case 3
+    return first_template_parameter.str() + R"(::operator\(\)\(.*\))";
+    ;
+  };
+
+  std::string func_to_match = get_name();
+
+  SymbolContextList scl;
+
+  target.GetImages().FindSymbolsMatchingRegExAndType(
+      RegularExpression{R"(^)" + func_to_match}, eSymbolTypeAny, scl, true);
+
+  // Case 1,2 or 3
+  if (scl.GetSize() >= 1) {
+    SymbolContext sc2 = scl[0];
+
+    AddressRange range;
+    sc2.GetAddressRange(eSymbolContextEverything, 0, false, range);
+
+    Address address = range.GetBaseAddress();
+
+    Address addr;
+    if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
+                                  addr)) {
+      LineEntry line_entry;
+      addr.CalculateSymbolContextLineEntry(line_entry);
+
+      if (first_template_parameter.contains("$_") ||
+          (symbol != nullptr &&
+           symbol->GetName().GetStringRef().contains("__invoke"))) {
+        // Case 1 and 2
+        optional_info.callable_case = LibCppStdFunctionCallableCase::Lambda;
+      } else {
+        // Case 3
+        optional_info.callable_case =
+            LibCppStdFunctionCallableCase::CallableObject;
+      }
+
+      optional_info.callable_symbol = *symbol;
+      optional_info.callable_line_entry = line_entry;
+      optional_info.callable_address = addr;
+      return optional_info;
+    }
+  }
+
+  // Case 4 or 5
+  if (symbol && !symbol->GetName().GetStringRef().startswith("vtable for")) {
+    optional_info.callable_case =
+        LibCppStdFunctionCallableCase::FreeOrMemberFunction;
+    optional_info.callable_address = function_address_resolved;
+    optional_info.callable_symbol = *symbol;
+
+    return optional_info;
+  }
+
+  return optional_info;
+}
+
+lldb::ThreadPlanSP
+CPPLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread,
+                                                 bool stop_others) {
+  ThreadPlanSP ret_plan_sp;
+
+  lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
+
+  TargetSP target_sp(thread.CalculateTarget());
+
+  if (target_sp->GetSectionLoadList().IsEmpty())
+    return ret_plan_sp;
+
+  Address pc_addr_resolved;
+  SymbolContext sc;
+  Symbol *symbol;
+
+  if (!target_sp->GetSectionLoadList().ResolveLoadAddress(curr_pc,
+                                                          pc_addr_resolved))
+    return ret_plan_sp;
+
+  target_sp->GetImages().ResolveSymbolContextForAddress(
+      pc_addr_resolved, eSymbolContextEverything, sc);
+  symbol = sc.symbol;
+
+  if (symbol == nullptr)
+    return ret_plan_sp;
+
+  llvm::StringRef function_name(symbol->GetName().GetCString());
+
+  // Handling the case where we are attempting to step into std::function.
+  // The behavior will be that we will attempt to obtain the wrapped
+  // callable via FindLibCppStdFunctionCallableInfo() and if we find it we
+  // will return a ThreadPlanRunToAddress to the callable. Therefore we will
+  // step into the wrapped callable.
+  //
+  bool found_expected_start_string =
+      function_name.startswith("std::__1::function<");
+
+  if (!found_expected_start_string)
+    return ret_plan_sp;
+
+  AddressRange range_of_curr_func;
+  sc.GetAddressRange(eSymbolContextEverything, 0, false, range_of_curr_func);
+
+  StackFrameSP frame = thread.GetStackFrameAtIndex(0);
+
+  if (frame) {
+    ValueObjectSP value_sp = frame->FindVariable(g_this);
+
+    CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
+        FindLibCppStdFunctionCallableInfo(value_sp);
+
+    if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid &&
+        value_sp->GetValueIsValid()) {
+      // We found the std::function wrapped callable and we have its address.
+      // We now create a ThreadPlan to run to the callable.
+      ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
+          thread, callable_info.callable_address, stop_others);
+      return ret_plan_sp;
+    } else {
+      // We are in std::function but we could not obtain the callable.
+      // We create a ThreadPlan to keep stepping through using the address range
+      // of the current function.
+      ret_plan_sp = std::make_shared<ThreadPlanStepInRange>(
+          thread, range_of_curr_func, sc, eOnlyThisThread, eLazyBoolYes,
+          eLazyBoolYes);
+      return ret_plan_sp;
+    }
+  }
+
+  return ret_plan_sp;
+}

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/CMakeLists.txt

 add_lldb_library(lldbPluginCXXItaniumABI PLUGIN
   ItaniumABILanguageRuntime.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbInterpreter
     lldbSymbol
     lldbTarget
+    lldbPluginCPPRuntime
   )

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h

 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/Type.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
+
 namespace lldb_private {
 
 class ItaniumABILanguageRuntime : public lldb_private::CPPLanguageRuntime {
 public:
   ~ItaniumABILanguageRuntime() override = default;
 
   // Static Functions
   static void Initialize();

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "Plugins/Process/Utility/HistoryThread.h"
 #include "Plugins/Language/ObjC/NSString.h"
+#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 char AppleObjCRuntime::ID = 0;
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/CMakeLists.txt

LINK_LIBS
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginExpressionParserClang
+    lldbPluginCPPRuntime
   LINK_COMPONENTS
     Support
   )

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

 #include <memory>
 #include <string>
 #include <vector>
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Expression/LLVMUserExpression.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
+
 namespace lldb_private {
 namespace lldb_renderscript {
 
 typedef uint32_t RSSlot;
 class RSModuleDescriptor;
 struct RSGlobalDescriptor;
 struct RSKernelDescriptor;
 struct RSReductionDescriptor;

lldb/trunk/source/Target/CMakeLists.txt

 add_lldb_library(lldbTarget
   ABI.cpp
-  CPPLanguageRuntime.cpp
   ExecutionContext.cpp
   JITLoader.cpp
   JITLoaderList.cpp
   InstrumentationRuntime.cpp
   InstrumentationRuntimeStopInfo.cpp
   Language.cpp
   LanguageRuntime.cpp
   Memory.cpp

lldb/trunk/source/Target/CPPLanguageRuntime.cpp

-//===-- CPPLanguageRuntime.cpp
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Target/CPPLanguageRuntime.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
-
-#include <string.h>
-
-#include <memory>
-
-#include "llvm/ADT/StringRef.h"
-
-#include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/Variable.h"
-#include "lldb/Symbol/VariableList.h"
-
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/UniqueCStringMap.h"
-#include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/ABI.h"
-#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/StackFrame.h"
-#include "lldb/Target/ThreadPlanRunToAddress.h"
-#include "lldb/Target/ThreadPlanStepInRange.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-static ConstString g_this = ConstString("this");
-
-char CPPLanguageRuntime::ID = 0;
-
-// Destructor
-CPPLanguageRuntime::~CPPLanguageRuntime() {}
-
-CPPLanguageRuntime::CPPLanguageRuntime(Process *process)
-    : LanguageRuntime(process) {}
-
-bool CPPLanguageRuntime::IsWhitelistedRuntimeValue(ConstString name) {
-  return name == g_this;
-}
-
-bool CPPLanguageRuntime::GetObjectDescription(Stream &str,
-                                              ValueObject &object) {
-  // C++ has no generic way to do this.
-  return false;
-}
-
-bool CPPLanguageRuntime::GetObjectDescription(
-    Stream &str, Value &value, ExecutionContextScope *exe_scope) {
-  // C++ has no generic way to do this.
-  return false;
-}
-
-CPPLanguageRuntime::LibCppStdFunctionCallableInfo
-CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
-    lldb::ValueObjectSP &valobj_sp) {
-  LibCppStdFunctionCallableInfo optional_info;
-
-  if (!valobj_sp)
-    return optional_info;
-
-  // Member __f_ has type __base*, the contents of which will hold:
-  // 1) a vtable entry which may hold type information needed to discover the
-  //    lambda being called
-  // 2) possibly hold a pointer to the callable object
-  // e.g.
-  //
-  // (lldb) frame var -R  f_display
-  // (std::__1::function<void (int)>) f_display = {
-  //  __buf_ = {
-  //  …
-  // }
-  //  __f_ = 0x00007ffeefbffa00
-  // }
-  // (lldb) memory read -fA 0x00007ffeefbffa00
-  // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ...
-  // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ...
-  //
-  // We will be handling five cases below, std::function is wrapping:
-  //
-  // 1) a lambda we know at compile time. We will obtain the name of the lambda
-  //    from the first template pameter from __func's vtable. We will look up
-  //    the lambda's operator()() and obtain the line table entry.
-  // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method
-  //    will be stored after the vtable. We will obtain the lambdas name from
-  //    this entry and lookup operator()() and obtain the line table entry.
-  // 3) a callable object via operator()(). We will obtain the name of the
-  //    object from the first template parameter from __func's vtable. We will
-  //    look up the objectc operator()() and obtain the line table entry.
-  // 4) a member function. A pointer to the function will stored after the
-  //    we will obtain the name from this pointer.
-  // 5) a free function. A pointer to the function will stored after the vtable
-  //    we will obtain the name from this pointer.
-  ValueObjectSP member__f_(
-      valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
-
-  if (member__f_) {
-    ValueObjectSP sub_member__f_(
-       member__f_->GetChildMemberWithName(ConstString("__f_"), true));
-
-    if (sub_member__f_)
-        member__f_ = sub_member__f_;
-  }
-
-  lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0);
-
-  optional_info.member__f_pointer_value = member__f_pointer_value;
-
-  ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
-  Process *process = exe_ctx.GetProcessPtr();
-
-  if (process == nullptr)
-    return optional_info;
-
-  uint32_t address_size = process->GetAddressByteSize();
-  Status status;
-
-  // First item pointed to by __f_ should be the pointer to the vtable for
-  // a __base object.
-  lldb::addr_t vtable_address =
-      process->ReadPointerFromMemory(member__f_pointer_value, status);
-
-  if (status.Fail())
-    return optional_info;
-
-  lldb::addr_t address_after_vtable = member__f_pointer_value + address_size;
-  // As commened above we may not have a function pointer but if we do we will
-  // need it.
-  lldb::addr_t possible_function_address =
-      process->ReadPointerFromMemory(address_after_vtable, status);
-
-  if (status.Fail())
-    return optional_info;
-
-  Target &target = process->GetTarget();
-
-  if (target.GetSectionLoadList().IsEmpty())
-    return optional_info;
-
-  Address vtable_addr_resolved;
-  SymbolContext sc;
-  Symbol *symbol;
-
-  if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address,
-                                                      vtable_addr_resolved))
-    return optional_info;
-
-  target.GetImages().ResolveSymbolContextForAddress(
-      vtable_addr_resolved, eSymbolContextEverything, sc);
-  symbol = sc.symbol;
-
-  if (symbol == nullptr)
-    return optional_info;
-
-  llvm::StringRef vtable_name(symbol->GetName().GetCString());
-  bool found_expected_start_string =
-      vtable_name.startswith("vtable for std::__1::__function::__func<");
-
-  if (!found_expected_start_string)
-    return optional_info;
-
-  // Given case 1 or 3 we have a vtable name, we are want to extract the first
-  // template parameter
-  //
-  //  ... __func<main::$_0, std::__1::allocator<main::$_0> ...
-  //             ^^^^^^^^^
-  //
-  // We do this by find the first < and , and extracting in between.
-  //
-  // This covers the case of the lambda known at compile time.
-  size_t first_open_angle_bracket = vtable_name.find('<') + 1;
-  size_t first_comma = vtable_name.find(',');
-
-  llvm::StringRef first_template_parameter =
-      vtable_name.slice(first_open_angle_bracket, first_comma);
-
-  Address function_address_resolved;
-
-  // Setup for cases 2, 4 and 5 we have a pointer to a function after the
-  // vtable. We will use a process of elimination to drop through each case
-  // and obtain the data we need.
-  if (target.GetSectionLoadList().ResolveLoadAddress(
-          possible_function_address, function_address_resolved)) {
-    target.GetImages().ResolveSymbolContextForAddress(
-        function_address_resolved, eSymbolContextEverything, sc);
-    symbol = sc.symbol;
-  }
-
-  auto get_name = [&first_template_parameter, &symbol]() {
-    // Given case 1:
-    //
-    //    main::$_0
-    //
-    // we want to append ::operator()()
-    if (first_template_parameter.contains("$_"))
-      return llvm::Regex::escape(first_template_parameter.str()) +
-             R"(::operator\(\)\(.*\))";
-
-    if (symbol != nullptr &&
-        symbol->GetName().GetStringRef().contains("__invoke")) {
-
-      llvm::StringRef symbol_name = symbol->GetName().GetStringRef();
-      size_t pos2 = symbol_name.find_last_of(':');
-
-      // Given case 2:
-      //
-      //    main::$_1::__invoke(...)
-      //
-      // We want to slice off __invoke(...) and append operator()()
-      std::string lambda_operator =
-          llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) +
-          R"(operator\(\)\(.*\))";
-
-      return lambda_operator;
-    }
-
-    // Case 3
-    return first_template_parameter.str() + R"(::operator\(\)\(.*\))";
-    ;
-  };
-
-  std::string func_to_match = get_name();
-
-  SymbolContextList scl;
-
-  target.GetImages().FindSymbolsMatchingRegExAndType(
-      RegularExpression{R"(^)" + func_to_match}, eSymbolTypeAny, scl, true);
-
-  // Case 1,2 or 3
-  if (scl.GetSize() >= 1) {
-    SymbolContext sc2 = scl[0];
-
-    AddressRange range;
-    sc2.GetAddressRange(eSymbolContextEverything, 0, false, range);
-
-    Address address = range.GetBaseAddress();
-
-    Address addr;
-    if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
-                                  addr)) {
-      LineEntry line_entry;
-      addr.CalculateSymbolContextLineEntry(line_entry);
-
-      if (first_template_parameter.contains("$_") ||
-          (symbol != nullptr &&
-           symbol->GetName().GetStringRef().contains("__invoke"))) {
-        // Case 1 and 2
-        optional_info.callable_case = LibCppStdFunctionCallableCase::Lambda;
-      } else {
-        // Case 3
-        optional_info.callable_case =
-            LibCppStdFunctionCallableCase::CallableObject;
-      }
-
-      optional_info.callable_symbol = *symbol;
-      optional_info.callable_line_entry = line_entry;
-      optional_info.callable_address = addr;
-      return optional_info;
-    }
-  }
-
-  // Case 4 or 5
-  if (symbol && !symbol->GetName().GetStringRef().startswith("vtable for")) {
-    optional_info.callable_case =
-        LibCppStdFunctionCallableCase::FreeOrMemberFunction;
-    optional_info.callable_address = function_address_resolved;
-    optional_info.callable_symbol = *symbol;
-
-    return optional_info;
-  }
-
-  return optional_info;
-}
-
-lldb::ThreadPlanSP
-CPPLanguageRuntime::GetStepThroughTrampolinePlan(Thread &thread,
-                                                 bool stop_others) {
-  ThreadPlanSP ret_plan_sp;
-
-  lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
-
-  TargetSP target_sp(thread.CalculateTarget());
-
-  if (target_sp->GetSectionLoadList().IsEmpty())
-    return ret_plan_sp;
-
-  Address pc_addr_resolved;
-  SymbolContext sc;
-  Symbol *symbol;
-
-  if (!target_sp->GetSectionLoadList().ResolveLoadAddress(curr_pc,
-                                                          pc_addr_resolved))
-    return ret_plan_sp;
-
-  target_sp->GetImages().ResolveSymbolContextForAddress(
-      pc_addr_resolved, eSymbolContextEverything, sc);
-  symbol = sc.symbol;
-
-  if (symbol == nullptr)
-    return ret_plan_sp;
-
-  llvm::StringRef function_name(symbol->GetName().GetCString());
-
-  // Handling the case where we are attempting to step into std::function.
-  // The behavior will be that we will attempt to obtain the wrapped
-  // callable via FindLibCppStdFunctionCallableInfo() and if we find it we
-  // will return a ThreadPlanRunToAddress to the callable. Therefore we will
-  // step into the wrapped callable.
-  //
-  bool found_expected_start_string =
-      function_name.startswith("std::__1::function<");
-
-  if (!found_expected_start_string)
-    return ret_plan_sp;
-
-  AddressRange range_of_curr_func;
-  sc.GetAddressRange(eSymbolContextEverything, 0, false, range_of_curr_func);
-
-  StackFrameSP frame = thread.GetStackFrameAtIndex(0);
-
-  if (frame) {
-    ValueObjectSP value_sp = frame->FindVariable(g_this);
-
-    CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
-        FindLibCppStdFunctionCallableInfo(value_sp);
-
-    if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid &&
-        value_sp->GetValueIsValid()) {
-      // We found the std::function wrapped callable and we have its address.
-      // We now create a ThreadPlan to run to the callable.
-      ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
-          thread, callable_info.callable_address, stop_others);
-      return ret_plan_sp;
-    } else {
-      // We are in std::function but we could not obtain the callable.
-      // We create a ThreadPlan to keep stepping through using the address range
-      // of the current function.
-      ret_plan_sp = std::make_shared<ThreadPlanStepInRange>(
-          thread, range_of_curr_func, sc, eOnlyThisThread, eLazyBoolYes,
-          eLazyBoolYes);
-      return ret_plan_sp;
-    }
-  }
-
-  return ret_plan_sp;
-}