[lldb] Add support for the DW_AT_trampoline attribute with a boolean

[augusto2112]

Summary

This patch adds support for the DW_AT_trampoline attribute whose value
is a boolean. Which is a "generic trampoline". Stepping into a generic
trampoline by default will step through the function, checking
at every branch, until we stop in a function which makes sense to stop
at (a function with debug info, which isn't a trampoline, for example).

[JDevlieghere]

There seems to be overlap in the code added in this patch and D146679. Does one supersede the other or is there a dependency? If it's the latter you should extract that into a separate patch and make it a parent revision of this and D146679.

[augusto2112]

In D147292#4238820, @JDevlieghere wrote:

There seems to be overlap in the code added in this patch and D146679. Does one supersede the other or is there a dependency? If it's the latter you should extract that into a separate patch and make it a parent revision of this and D146679.

Yes, sorry, I'm abandoning the other one in favor of this one.

[JDevlieghere]

lldb/source/Core/Module.cpp

782

You can hoist target::GetGlobalProperties().GetEnableTrampolineSupport() out of the loop. Right now it will need to be recomputed every time in because someone could change the setting in the meantime and although it's a little far fetched, that's probably not what you want anyway.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2443

Let's make this const for consistence with func_user_id (and remove the newline as they're related).

lldb/source/Target/ThreadPlanStepRange.cpp

509–527

I know you copy pasted this but this can be simplified quite a bit.

[dblaikie]

In D147292#4238834, @augusto2112 wrote:

In D147292#4238820, @JDevlieghere wrote:

There seems to be overlap in the code added in this patch and D146679. Does one supersede the other or is there a dependency? If it's the latter you should extract that into a separate patch and make it a parent revision of this and D146679.

Yes, sorry, I'm abandoning the other one in favor of this one.

Be handy to mark this abandoned when you get a chance

[JDevlieghere]

Be handy to mark this abandoned when you get a chance

Augusto had already abandoned it when he wrote that reply, maybe you're looking at a different patch or stale tab?

[augusto2112]

Addressed comments

[aprantl]

lldb/include/lldb/Symbol/Function.h

439

Is the "generic" qualifier necessary here? If we later add support for trampolines with a jump target maybe, but without that this seems to just create opportunity for confusion, particularly for Swift where the word "generic" has very different connotations.

lldb/source/Target/ThreadPlanStepThroughGenericTrampoline.cpp

2

formatting

[JDevlieghere]

LGTM with Adrian's and my comments addressed.

lldb/include/lldb/Symbol/Function.h

439

I wondered that too, but assumed we were still planning to support trampolines with a target. If not, then +1 on making this just "trampoline".

lldb/source/Target/ThreadPlanStepRange.cpp

520–522

LLDB_LOG(GetLog(LLDBLog::Step), "ThreadPlanStepRange got asked if it explains the stop for some reason other than step.");

lldb/include/lldb/Symbol/Function.h

public:
   /// \param[in] func_type
   ///     The optional function type. If NULL, the function type will
   ///     be parsed on demand when accessed using the
   ///     Function::GetType() function by asking the SymbolFile
   ///     plug-in to get the type for \a func_type_uid.
   ///
   /// \param[in] range
   ///     The section offset based address for this function.
+  /// \param[in] generic_trampoline
+  ///     If this function is a generic trampoline. A generic trampoline 
+  ///     is a function without any annotations on what the trampoline 
+  ///     target is.
   Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
            lldb::user_id_t func_type_uid, const Mangled &mangled,
-           Type *func_type, const AddressRange &range);
+           Type *func_type, const AddressRange &range,
+           bool generic_trampoline = false);
 
   /// Destructor.
   ~Function() override;
 
   /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
   ///
   /// \see SymbolContextScope
   void CalculateSymbolContext(SymbolContext *sc) override;
public:
 
   /// Get accessor for the type that describes the function return value type,
   /// and parameter types.
   ///
   /// \return
   ///     A type object pointer.
   Type *GetType();
 
+  bool IsGenericTrampoline() const {
+    return m_is_generic_trampoline;
+  }
+
   /// Get const accessor for the type that describes the function return value
   /// type, and parameter types.
   ///
   /// \return
   ///     A const type object pointer.
   const Type *GetType() const;
 
   CompilerType GetCompilerType();
protected:
   /// The function prototype type for this function that includes the function
   /// info (FunctionInfo), return type and parameters.
   Type *m_type;
 
   /// The mangled function name if any. If empty, there is no mangled
   /// information.
   Mangled m_mangled;
 
+  bool m_is_generic_trampoline;
+
   /// All lexical blocks contained in this function.
   Block m_block;
 
   /// The function address range that covers the widest range needed to contain
   /// all blocks
   AddressRange m_range;
 
   /// The frame base expression for variables that are relative to the frame

lldb/include/lldb/Target/Target.h

public:
   bool GetAutoInstallMainExecutable() const;
 
   void UpdateLaunchInfoFromProperties();
 
   void SetDebugUtilityExpression(bool debug);
 
   bool GetDebugUtilityExpression() const;
 
+  /// Trampoline support includes stepping through trampolines directly to their
+  /// targets, stepping out of trampolines directly to their callers, and
+  /// automatically filtering out trampolines as possible breakpoint locations
+  /// when set by name.
+  bool GetEnableTrampolineSupport() const;
+
 private:
   // Callbacks for m_launch_info.
   void Arg0ValueChangedCallback();
   void RunArgsValueChangedCallback();
   void EnvVarsValueChangedCallback();
   void InputPathValueChangedCallback();
   void OutputPathValueChangedCallback();
   void ErrorPathValueChangedCallback();

lldb/include/lldb/Target/Thread.h

public:
   /// \return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   virtual lldb::ThreadPlanSP
   QueueThreadPlanForStepThrough(StackID &return_stack_id,
                                 bool abort_other_plans, bool stop_other_threads,
                                 Status &status);
 
+  /// Gets the plan used to step through a function with a generic trampoline. A
+  /// generic trampoline is one without a function target, which the thread plan
+  /// will attempt to step through until it finds a place where it makes sense
+  /// to stop at. 
+  /// \param[in] abort_other_plans
+  ///    \b true if we discard the currently queued plans and replace them with
+  ///    this one.
+  ///    Otherwise this plan will go on the end of the plan stack.
+  ///
+  /// \param[in] stop_other_threads
+  ///    \b true if we will stop other threads while we single step this one.
+  ///
+  /// \param[out] status
+  ///     A status with an error if queuing failed.
+  ///
+  /// \return
+  ///     A shared pointer to the newly queued thread plan, or nullptr if the
+  ///     plan could not be queued.
+  virtual lldb::ThreadPlanSP QueueThreadPlanForStepThroughGenericTrampoline(
+      bool abort_other_plans, lldb::RunMode stop_other_threads, Status &status);
+
   /// Gets the plan used to continue from the current PC.
   /// This is a simple plan, mostly useful as a backstop when you are continuing
   /// for some particular purpose.
   ///
   /// \param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.

lldb/include/lldb/Target/ThreadPlan.h

enum ThreadPlanKind {
     eKindPython,
     eKindStepInstruction,
     eKindStepOut,
     eKindStepOverBreakpoint,
     eKindStepOverRange,
     eKindStepInRange,
     eKindRunToAddress,
     eKindStepThrough,
+    eKindStepThroughGenericTrampoline,
     eKindStepUntil
   };
 
   virtual ~ThreadPlan();
 
   /// Returns the name of this thread plan.
   ///
   /// \return

lldb/include/lldb/Target/ThreadPlanStepOverRange.h

ThreadPlanStepOverRange(Thread &thread, const AddressRange &range,
                           LazyBool step_out_avoids_no_debug);
 
   ~ThreadPlanStepOverRange() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
   bool ShouldStop(Event *event_ptr) override;
 
 protected:
-  bool DoPlanExplainsStop(Event *event_ptr) override;
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
   void SetFlagsToDefault() override {
     GetFlags().Set(ThreadPlanStepOverRange::s_default_flag_values);
   }
 
 private:
   static uint32_t s_default_flag_values;

lldb/include/lldb/Target/ThreadPlanStepRange.h

public:
   bool WillStop() override;
   bool MischiefManaged() override;
   void DidPush() override;
   bool IsPlanStale() override;
 
   void AddRange(const AddressRange &new_range);
 
 protected:
+  bool DoPlanExplainsStop(Event *event_ptr) override;
   bool InRange();
   lldb::FrameComparison CompareCurrentFrameToStartFrame();
   bool InSymbol();
   void DumpRanges(Stream *s);
 
   Disassembler *GetDisassembler();
 
   InstructionList *GetInstructionsForAddress(lldb::addr_t addr,

lldb/include/lldb/Target/ThreadPlanStepThroughGenericTrampoline.h

+//===-- ThreadPlanStepInRange.h ---------------------------------*- C++ -*-===//
+//
+// 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 LLDB_TARGET_THREADPLANSTEPTHROUGHGENERICTRAMPOLINE_H
+#define LLDB_TARGET_THREADPLANSTEPTHROUGHGENERICTRAMPOLINE_H
+
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlanShouldStopHere.h"
+#include "lldb/Target/ThreadPlanStepRange.h"
+
+namespace lldb_private {
+
+class ThreadPlanStepThroughGenericTrampoline : public ThreadPlanStepRange,
+                                               public ThreadPlanShouldStopHere {
+public:
+  ThreadPlanStepThroughGenericTrampoline(Thread &thread,
+                                         lldb::RunMode stop_others);
+
+  ~ThreadPlanStepThroughGenericTrampoline() override;
+
+  void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+
+  bool ShouldStop(Event *event_ptr) override;
+  bool ValidatePlan(Stream *error) override;
+
+protected:
+  void SetFlagsToDefault() override {
+    GetFlags().Set(
+        ThreadPlanStepThroughGenericTrampoline::s_default_flag_values);
+  }
+
+private:
+  // Need an appropriate marker for the current stack so we can tell step out
+  // from step in.
+
+  static uint32_t
+      s_default_flag_values; // These are the default flag values
+                             // for the ThreadPlanStepThroughGenericTrampoline.
+  ThreadPlanStepThroughGenericTrampoline(
+      const ThreadPlanStepThroughGenericTrampoline &) = delete;
+  const ThreadPlanStepThroughGenericTrampoline &
+  operator=(const ThreadPlanStepThroughGenericTrampoline &) = delete;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_THREADPLANSTEPTHROUGHGENERICTRAMPOLINE_H

lldb/source/Core/Module.cpp

bool Module::LookupInfo::NameMatchesLookupInfo(
   return function_name_ref.contains(m_name.GetStringRef());
 }
 
 void Module::LookupInfo::Prune(SymbolContextList &sc_list,
                                size_t start_idx) const {
   if (m_match_name_after_lookup && m_name) {
     SymbolContext sc;
     size_t i = start_idx;
+    bool trampoline_support_enabled =
+        Target::GetGlobalProperties().GetEnableTrampolineSupport();
     while (i < sc_list.GetSize()) {
       if (!sc_list.GetContextAtIndex(i, sc))
         break;
 
+      bool is_trampoline = trampoline_support_enabled && sc.function &&
+                           sc.function->IsGenericTrampoline();
+
       bool keep_it =
+          !is_trampoline &&
           NameMatchesLookupInfo(sc.GetFunctionName(), sc.GetLanguage());
       if (keep_it)
         ++i;
       else
         sc_list.RemoveContextAtIndex(i);
     }
   }
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (decl_file || decl_line || decl_column)
           decl_line ? *decl_line : 0, decl_column ? *decl_column : 0);
 
     SymbolFileDWARF *dwarf = die.GetDWARF();
     // Supply the type _only_ if it has already been parsed
     Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
 
     assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
+    const bool is_generic_trampoline = die.IsGenericTrampoline();
     const user_id_t func_user_id = die.GetID();
     func_sp =
         std::make_shared<Function>(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
-                                   func_range); // first address range
+                                   func_range, // first address range
+                                   is_generic_trampoline);
 
     if (func_sp.get() != nullptr) {
       if (frame_base.IsValid())
         func_sp->GetFrameBaseExpression() = frame_base;
       comp_unit.AddFunction(func_sp);
       return func_sp.get();
     }
   }

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h

public:
 
   bool IsMethod() const;
 
   // Accessors
 
   // Accessing information about a DIE
   const char *GetMangledName() const;
 
+  bool IsGenericTrampoline() const;
+
   const char *GetPubname() const;
 
   using DWARFBaseDIE::GetName;
   void GetName(lldb_private::Stream &s) const;
 
   void AppendTypeName(lldb_private::Stream &s) const;
 
   lldb_private::Type *ResolveType() const;

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 
 const char *DWARFDIE::GetMangledName() const {
   if (IsValid())
     return m_die->GetMangledName(m_cu);
   else
     return nullptr;
 }
 
+bool DWARFDIE::IsGenericTrampoline() const {
+  if (IsValid())
+    return m_die->GetIsGenericTrampoline(m_cu);
+  else
+    return false;
+}
+
 const char *DWARFDIE::GetPubname() const {
   if (IsValid())
     return m_die->GetPubname(m_cu);
   else
     return nullptr;
 }
 
 // GetName

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

size_t GetAttributeAddressRanges(
       DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc,
       bool check_specification_or_abstract_origin = false) const;
 
   const char *GetName(const DWARFUnit *cu) const;
 
   const char *GetMangledName(const DWARFUnit *cu,
                              bool substitute_name_allowed = true) const;
 
+  bool GetIsGenericTrampoline(const DWARFUnit *cu) const;
+
   const char *GetPubname(const DWARFUnit *cu) const;
 
   bool GetDIENamesAndRanges(
       DWARFUnit *cu, const char *&name, const char *&mangled,
       DWARFRangeList &rangeList, std::optional<int> &decl_file,
       std::optional<int> &decl_line, std::optional<int> &decl_column,
       std::optional<int> &call_file, std::optional<int> &call_line,
       std::optional<int> &call_column,

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu,
 
   if (!substitute_name_allowed)
     return nullptr;
 
   name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
   return name;
 }
 
+bool
+DWARFDebugInfoEntry::GetIsGenericTrampoline(const DWARFUnit *cu) const {
+  DWARFFormValue form_value;
+  return GetAttributeValue(cu, DW_AT_trampoline, form_value, nullptr, true) !=
+         0;
+}
+
 // GetPubname
 //
 // Get value the name for a DIE as it should appear for a .debug_pubnames or
 // .debug_pubtypes section.
 const char *DWARFDebugInfoEntry::GetPubname(const DWARFUnit *cu) const {
   const char *name = nullptr;
   if (!cu)
     return name;

lldb/source/Symbol/Function.cpp

Function *IndirectCallEdge::GetCallee(ModuleList &images,
   return f;
 }
 
 /// @}
 
 //
 Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
                    lldb::user_id_t type_uid, const Mangled &mangled, Type *type,
-                   const AddressRange &range)
+                   const AddressRange &range, bool is_generic_trampoline)
     : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
-      m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
-      m_frame_base(), m_flags(), m_prologue_byte_size(0) {
+      m_type(type), m_mangled(mangled),
+      m_is_generic_trampoline(is_generic_trampoline), m_block(func_uid),
+      m_range(range), m_frame_base(), m_flags(), m_prologue_byte_size(0) {
   m_block.SetParentScope(this);
   assert(comp_unit != nullptr);
 }
 
 Function::~Function() = default;
 
 void Function::GetStartLineSourceInfo(FileSpec &source_file,
                                       uint32_t &line_no) {

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   ThreadPlanShouldStopHere.cpp
   ThreadPlanStepInRange.cpp
   ThreadPlanStepInstruction.cpp
   ThreadPlanStepOut.cpp
   ThreadPlanStepOverBreakpoint.cpp
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
+  ThreadPlanStepThroughGenericTrampoline.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp
   ThreadSpec.cpp
   Trace.cpp
   TraceCursor.cpp
   TraceExporter.cpp
   TraceDumper.cpp

lldb/source/Target/Target.cpp

 }
 
 bool TargetProperties::GetDebugUtilityExpression() const {
   const uint32_t idx = ePropertyDebugUtilityExpression;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_target_properties[idx].default_uint_value != 0);
 }
 
+bool TargetProperties::GetEnableTrampolineSupport() const {
+  const uint32_t idx = ePropertyEnableTrampolineSupport;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_target_properties[idx].default_uint_value != 0);
+}
+
 void TargetProperties::SetDebugUtilityExpression(bool debug) {
   const uint32_t idx = ePropertyDebugUtilityExpression;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, debug);
 }
 
 // Target::TargetEventData
 
 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp)

lldb/source/Target/TargetProperties.td

def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">,
     DefaultFalse,
     Desc<"Require all breakpoints to be hardware breakpoints.">;
   def AutoInstallMainExecutable: Property<"auto-install-main-executable", "Boolean">,
     DefaultTrue,
     Desc<"Always install the main executable when connected to a remote platform.">;
   def DebugUtilityExpression: Property<"debug-utility-expression", "Boolean">,
     DefaultFalse,
     Desc<"Enable debugging of LLDB-internal utility expressions.">;
+  def EnableTrampolineSupport: Property<"enable-trampoline-support", "Boolean">,
+    Global, DefaultTrue,
+    Desc<"Enable trampoline support in LLDB. Trampoline support includes stepping through trampolines directly to their targets, stepping out of trampolines directly to their callers, and automatically filtering out trampolines as possible breakpoint locations when set by name.">;
 }
 
 let Definition = "process_experimental" in {
   def OSPluginReportsAllThreads: Property<"os-plugin-reports-all-threads", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"Set to False if your OS Plugins doesn't report all threads on each stop.">;
 }

lldb/source/Target/Thread.cpp

 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStack.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
 #include "lldb/Target/ThreadPlanStepOverRange.h"
 #include "lldb/Target/ThreadPlanStepThrough.h"
+#include "lldb/Target/ThreadPlanStepThroughGenericTrampoline.h"
 #include "lldb/Target/ThreadPlanStepUntil.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/UnwindLLDB.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
ThreadPlanSP thread_plan_sp(
       new ThreadPlanStepThrough(*this, return_stack_id, stop_other_threads));
   if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr))
     return ThreadPlanSP();
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
+ThreadPlanSP Thread::QueueThreadPlanForStepThroughGenericTrampoline(
+    bool abort_other_plans, lldb::RunMode stop_other_threads, Status &status) {
+  ThreadPlanSP thread_plan_sp(
+      new ThreadPlanStepThroughGenericTrampoline(*this, stop_other_threads));
+
+  if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr))
+    return ThreadPlanSP();
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  return thread_plan_sp;
+}
+
 ThreadPlanSP Thread::QueueThreadPlanForRunToAddress(bool abort_other_plans,
                                                     Address &target_addr,
                                                     bool stop_other_threads,
                                                     Status &status) {
   ThreadPlanSP thread_plan_sp(
       new ThreadPlanRunToAddress(*this, target_addr, stop_other_threads));
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);

lldb/source/Target/ThreadPlanShouldStopHere.cpp

 //===-- ThreadPlanShouldStopHere.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/ThreadPlanShouldStopHere.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
if ((operation == eFrameCompareOlder && flags.Test(eStepOutAvoidNoDebug)) ||
     }
   }
 
   // Always avoid code with line number 0.
   // FIXME: At present the ShouldStop and the StepFromHere calculate this
   // independently.  If this ever
   // becomes expensive (this one isn't) we can try to have this set a state
   // that the StepFromHere can use.
-  if (frame) {
-    SymbolContext sc;
-    sc = frame->GetSymbolContext(eSymbolContextLineEntry);
-    if (sc.line_entry.line == 0)
-      should_stop_here = false;
+
+
+  // If we're in a trampoline, don't stop by default.
+  if (Target::GetGlobalProperties().GetEnableTrampolineSupport()) {
+    sc = frame->GetSymbolContext(lldb::eSymbolContextFunction);
+    if (sc.function && sc.function->IsGenericTrampoline())
+      should_stop_here = false;
   }
 
   return should_stop_here;
 }
 
 ThreadPlanSP ThreadPlanShouldStopHere::DefaultStepFromHereCallback(
     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
     Status &status, void *baton) {

lldb/source/Target/ThreadPlanStepInRange.cpp

if (m_virtual_step) {
 
     // If we get to this point, we're not going to use a previously set "next
     // branch" breakpoint, so delete it:
     ClearNextBranchBreakpoint();
 
     // We may have set the plan up above in the FrameIsOlder section:
 
     if (!m_sub_plan_sp)
+      m_sub_plan_sp = thread.QueueThreadPlanForStepThroughGenericTrampoline(
+          false, m_stop_others, m_status);
+    if (log) {
+      if (m_sub_plan_sp)
+        LLDB_LOGF(log, "Found a generic step through plan: %s",
+                  m_sub_plan_sp->GetName());
+      else
+        LLDB_LOGF(log, "No generic step through plan found.");
+    }
+
+    if (!m_sub_plan_sp)
       m_sub_plan_sp = thread.QueueThreadPlanForStepThrough(
           m_stack_id, false, stop_others, m_status);
 
     if (log) {
       if (m_sub_plan_sp)
         LLDB_LOGF(log, "Found a step through plan: %s",
                   m_sub_plan_sp->GetName());
       else
bool ThreadPlanStepInRange::DoPlanExplainsStop(Event *event_ptr) {
   // plan, since you still may want to complete that plan when you continue.
   // This is particularly true when doing "step in to target function."
   // stepping.
   //
   // The only variation is that if we are doing "step by running to next
   // branch" in which case if we hit our branch breakpoint we don't set the
   // plan to complete.
 
-  bool return_value = false;
-
-  if (m_virtual_step) {
-    return_value = true;
-  } else {
-    StopInfoSP stop_info_sp = GetPrivateStopInfo();
-    if (stop_info_sp) {
-      StopReason reason = stop_info_sp->GetStopReason();
-
-      if (reason == eStopReasonBreakpoint) {
-        if (NextRangeBreakpointExplainsStop(stop_info_sp)) {
-          return_value = true;
-        }
-      } else if (IsUsuallyUnexplainedStopReason(reason)) {
-        Log *log = GetLog(LLDBLog::Step);
-        if (log)
-          log->PutCString("ThreadPlanStepInRange got asked if it explains the "
-                          "stop for some reason other than step.");
-        return_value = false;
-      } else {
-        return_value = true;
-      }
-    } else
-      return_value = true;
-  }
-
-  return return_value;
+  return m_virtual_step || ThreadPlanStepRange::DoPlanExplainsStop(event_ptr);
 }
 
 bool ThreadPlanStepInRange::DoWillResume(lldb::StateType resume_state,
                                          bool current_plan) {
   m_virtual_step = false;
   if (resume_state == eStateStepping && current_plan) {
     Thread &thread = GetThread();
     // See if we are about to step over a virtual inlined call.

lldb/source/Target/ThreadPlanStepOverRange.cpp

if (!new_plan_sp) {
     // For efficiencies sake, we know we're done here so we don't have to do
     // this calculation again in MischiefManaged.
     SetPlanComplete(m_status.Success());
     return true;
   } else
     return false;
 }
 
-bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) {
-  // For crashes, breakpoint hits, signals, etc, let the base plan (or some
-  // plan above us) handle the stop.  That way the user can see the stop, step
-  // around, and then when they are done, continue and have their step
-  // complete.  The exception is if we've hit our "run to next branch"
-  // breakpoint. Note, unlike the step in range plan, we don't mark ourselves
-  // complete if we hit an unexplained breakpoint/crash.
-
-  Log *log = GetLog(LLDBLog::Step);
-  StopInfoSP stop_info_sp = GetPrivateStopInfo();
-  bool return_value;
-
-  if (stop_info_sp) {
-    StopReason reason = stop_info_sp->GetStopReason();
-
-    if (reason == eStopReasonTrace) {
-      return_value = true;
-    } else if (reason == eStopReasonBreakpoint) {
-      return_value = NextRangeBreakpointExplainsStop(stop_info_sp);
-    } else {
-      if (log)
-        log->PutCString("ThreadPlanStepInRange got asked if it explains the "
-                        "stop for some reason other than step.");
-      return_value = false;
-    }
-  } else
-    return_value = true;
-
-  return return_value;
-}
-
 bool ThreadPlanStepOverRange::DoWillResume(lldb::StateType resume_state,
                                            bool current_plan) {
   if (resume_state != eStateSuspended && m_first_resume) {
     m_first_resume = false;
     if (resume_state == eStateStepping && current_plan) {
       Thread &thread = GetThread();
       // See if we are about to step over an inlined call in the middle of the
       // inlined stack, if so figure out its extents and reset our range to

lldb/source/Target/ThreadPlanStepRange.cpp

if (!InRange()) {
           SetPlanComplete();
         }
       }
       return true;
     }
   }
   return false;
 }
+
+bool ThreadPlanStepRange::DoPlanExplainsStop(Event *event_ptr) {
+  // For crashes, breakpoint hits, signals, etc, let the base plan (or some
+  // plan above us) handle the stop.  That way the user can see the stop, step
+  // around, and then when they are done, continue and have their step
+  // complete.  The exception is if we've hit our "run to next branch"
+  // breakpoint. Note, unlike the step in range plan, we don't mark ourselves
+  // complete if we hit an unexplained breakpoint/crash.
+
+  Log *log = GetLog(LLDBLog::Step);
+  StopInfoSP stop_info_sp = GetPrivateStopInfo();
+
+  if (!stop_info_sp)
+    return true;
+
+  StopReason reason = stop_info_sp->GetStopReason();
+
+  if (reason == eStopReasonTrace) 
+    return true;
+  
+  if (reason == eStopReasonBreakpoint) 
+    return NextRangeBreakpointExplainsStop(stop_info_sp);
+  
+  if (log)
+    log->PutCString("ThreadPlanStepRange got asked if it explains the "
+                    "stop for some reason other than step.");
+  return false;
+}

lldb/source/Target/ThreadPlanStepThrough.cpp

ThreadPlanStepThrough::ThreadPlanStepThrough(Thread &thread,
                                              StackID &m_stack_id,
                                              bool stop_others)
     : ThreadPlan(ThreadPlan::eKindStepThrough,
                  "Step through trampolines and prologues", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_start_address(0), m_backstop_bkpt_id(LLDB_INVALID_BREAK_ID),
       m_backstop_addr(LLDB_INVALID_ADDRESS), m_return_stack_id(m_stack_id),
       m_stop_others(stop_others) {
+  // If trampoline support is disabled, there's nothing for us to do.
+  if (!Target::GetGlobalProperties().GetEnableTrampolineSupport())
+    return;
+
   LookForPlanToStepThroughFromCurrentPC();
 
   // If we don't get a valid step through plan, don't bother to set up a
   // backstop.
   if (m_sub_plan_sp) {
     m_start_address = GetThread().GetRegisterContext()->GetPC(0);
 
     // We are going to return back to the concrete frame 1, we might pass by

lldb/source/Target/ThreadPlanStepThroughGenericTrampoline.cpp

+//===-- ThreadPlanStepThroughGenericTrampoline.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/ThreadPlanStepThroughGenericTrampoline.h"
+#include "lldb/Symbol/Function.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+uint32_t ThreadPlanStepThroughGenericTrampoline::s_default_flag_values =
+    ThreadPlanShouldStopHere::eStepInAvoidNoDebug;
+
+ThreadPlanStepThroughGenericTrampoline::ThreadPlanStepThroughGenericTrampoline(
+    Thread &thread, lldb::RunMode stop_others)
+    : ThreadPlanStepRange(ThreadPlan::eKindStepThroughGenericTrampoline,
+                          "Step through generic trampoline", thread, {}, {},
+                          stop_others),
+      ThreadPlanShouldStopHere(this) {
+
+  SetFlagsToDefault();
+  auto frame = GetThread().GetFrameWithStackID(m_stack_id);
+  if (!frame)
+    return;
+  SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction);
+
+  if (!sc.function)
+    return;
+  AddRange(sc.function->GetAddressRange());
+}
+
+ThreadPlanStepThroughGenericTrampoline::
+    ~ThreadPlanStepThroughGenericTrampoline() = default;
+
+void ThreadPlanStepThroughGenericTrampoline::GetDescription(
+    Stream *s, lldb::DescriptionLevel level) {
+
+  auto PrintFailureIfAny = [&]() {
+    if (m_status.Success())
+      return;
+    s->Printf(" failed (%s)", m_status.AsCString());
+  };
+
+  if (level == lldb::eDescriptionLevelBrief) {
+    s->Printf("step through generic trampoline");
+    PrintFailureIfAny();
+    return;
+  }
+
+  auto frame = GetThread().GetFrameWithStackID(m_stack_id);
+  if (!frame) {
+    s->Printf("<error, frame not available>");
+    return;
+  }
+
+  SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction);
+  if (!sc.function) {
+    s->Printf("<error, function not available>");
+    return;
+  }
+
+  s->Printf("Stepping through generic trampoline %s",
+            sc.function->GetName().AsCString());
+
+  lldb::StackFrameSP curr_frame = GetThread().GetStackFrameAtIndex(0);
+  if (!curr_frame)
+    return;
+
+  SymbolContext curr_frame_sc =
+      curr_frame->GetSymbolContext(eSymbolContextFunction);
+  if (!curr_frame_sc.function)
+    return;
+  s->Printf(", current function: %s",
+            curr_frame_sc.function->GetName().GetCString());
+
+  PrintFailureIfAny();
+
+  s->PutChar('.');
+}
+
+bool ThreadPlanStepThroughGenericTrampoline::ShouldStop(Event *event_ptr) {
+  Log *log = GetLog(LLDBLog::Step);
+
+  if (log) {
+    StreamString s;
+    DumpAddress(s.AsRawOstream(), GetThread().GetRegisterContext()->GetPC(),
+                GetTarget().GetArchitecture().GetAddressByteSize());
+    LLDB_LOGF(log, "ThreadPlanStepThroughGenericTrampoline reached %s.",
+              s.GetData());
+  }
+
+  if (IsPlanComplete())
+    return true;
+
+  m_no_more_plans = false;
+
+  Thread &thread = GetThread();
+  lldb::StackFrameSP curr_frame = thread.GetStackFrameAtIndex(0);
+  if (!curr_frame)
+    return false;
+
+  SymbolContext sc = curr_frame->GetSymbolContext(eSymbolContextFunction);
+
+  if (sc.function && sc.function->IsGenericTrampoline() &&
+      SetNextBranchBreakpoint()) {
+    // While whatever frame we're in is a generic trampoline,
+    // continue stepping to the next branch, until we
+    // end up in a function which isn't a trampoline.
+    return false;
+  }
+
+  m_no_more_plans = true;
+  SetPlanComplete();
+  return true;
+}
+
+bool ThreadPlanStepThroughGenericTrampoline::ValidatePlan(Stream *error) {
+  // If trampoline support is disabled, there's nothing for us to do.
+  if (!Target::GetGlobalProperties().GetEnableTrampolineSupport())
+    return false;
+
+  auto frame = GetThread().GetFrameWithStackID(m_stack_id);
+  if (!frame)
+    return false;
+
+  SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction);
+  return sc.function && sc.function->IsGenericTrampoline();
+}

lldb/test/API/lang/c/trampoline_stepping/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/lang/c/trampoline_stepping/TestTrampolineStepping.py

+"""Test that stepping in/out of trampolines works as expected.
+"""
+
+
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestTrampoline(TestBase):
+    def setup(self, bkpt_str):
+        self.build()
+        
+        _, _, thread, _ = lldbutil.run_to_source_breakpoint(
+            self, bkpt_str, lldb.SBFileSpec('main.c'))
+        return thread
+
+    def test_direct_call(self):
+        thread = self.setup('Break here for direct')
+
+        # Sanity check that we start out in the correct function.
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('direct_trampoline_call', name)
+
+        # Check that stepping in will take us directly to the trampoline target.
+        thread.StepInto()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('foo', name)
+
+        # Check that stepping out takes us back to the trampoline caller.
+        thread.StepOut()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('direct_trampoline_call', name)
+
+        # Check that stepping over the end of the trampoline target 
+        # takes us back to the trampoline caller.
+        thread.StepInto()
+        thread.StepOver()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('direct_trampoline_call', name)
+
+
+    def test_chained_call(self):
+        thread = self.setup('Break here for chained')
+
+        # Sanity check that we start out in the correct function.
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('chained_trampoline_call', name)
+
+        # Check that stepping in will take us directly to the trampoline target.
+        thread.StepInto()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('foo', name)
+
+        # Check that stepping out takes us back to the trampoline caller.
+        thread.StepOut()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('chained_trampoline_call', name)
+
+        # Check that stepping over the end of the trampoline target 
+        # takes us back to the trampoline caller.
+        thread.StepInto()
+        thread.StepOver()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('chained_trampoline_call', name)
+
+    def test_trampoline_after_nodebug(self):
+        thread = self.setup('Break here for nodebug then trampoline')
+
+        # Sanity check that we start out in the correct function.
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('trampoline_after_nodebug', name)
+
+        # Check that stepping in will take us directly to the trampoline target.
+        thread.StepInto()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('foo', name)
+
+        # Check that stepping out takes us back to the trampoline caller.
+        thread.StepOut()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('trampoline_after_nodebug', name)
+
+        # Check that stepping over the end of the trampoline target 
+        # takes us back to the trampoline caller.
+        thread.StepInto()
+        thread.StepOver()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('trampoline_after_nodebug', name)
+
+    def test_unused_target(self):
+        thread = self.setup('Break here for unused')
+
+        # Sanity check that we start out in the correct function.
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('unused_target', name)
+
+        # Check that stepping into a trampoline that doesn't call its target
+        # jumps back to its caller.
+        thread.StepInto()
+        name = thread.frames[0].GetFunctionName()
+        self.assertIn('unused_target', name)
+        

lldb/test/API/lang/c/trampoline_stepping/main.c

+void foo(void) {}
+
+__attribute__((debug_trampoline))
+void bar(void) {
+  foo();
+}
+
+__attribute__((debug_trampoline))
+void baz(void) {
+  bar();
+}
+
+__attribute__((nodebug))
+void nodebug(void) {}
+
+__attribute__((debug_trampoline))
+void nodebug_then_trampoline(void) {
+  nodebug();
+  baz();
+}
+
+__attribute__((debug_trampoline))
+void doesnt_call_trampoline(void) {}
+
+void direct_trampoline_call(void) {
+  bar(); // Break here for direct 
+  bar();
+}
+
+void chained_trampoline_call(void) {
+  baz(); // Break here for chained
+  baz();
+}
+
+void trampoline_after_nodebug(void) {
+  nodebug_then_trampoline(); // Break here for nodebug then trampoline
+  nodebug_then_trampoline();
+}
+
+void unused_target(void) {
+  doesnt_call_trampoline(); // Break here for unused
+}
+
+
+int main(void) {
+  direct_trampoline_call();
+  chained_trampoline_call();
+  trampoline_after_nodebug();
+  unused_target();
+  return 0;
+}
+