[lldb] Add support for the DW_AT_trampoline attribute with mangled names

[augusto2112]

Summary

This patch adds support for the DW_AT_trampoline attribute whose values
are mangled names. This patch makes it so stepping into a trampoline
will step through to the target subprogram instead, stepping out from the
target subprogram will also step out of the trampoline, and that setting
breakpoints by name will (by default) ignore trampolines.

[bulbazord]

lldb/include/lldb/Symbol/Function.h

439

lldb/source/Core/Module.cpp

782

The logic here is a little confusing. If the function is not a trampoline, then is_trampoline is true? Below, keep_it can only be true if we're not looking at a trampoline. So if a function is not a trampoline, we cannot keep it. Am I understanding the logic here incorrectly?

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

2450–2451

nit: this comment could be updated to indicate that it's referring to func_range.

lldb/source/Target/TargetProperties.td

187

[JDevlieghere]

lldb/include/lldb/Symbol/Function.h

665

I'd like to see a doxygen comment (1) explaining what the trampoline target is (i.e. according to the summary the mangled name of the trampoline target) and also why it's safe to store a StringRef. I didn't trace the lifetime but it seems like the StringRef is coming from a SymbolContext. Is the lifetime of the SC guaranteed to exceed that of the function object? If not, should this store an owning std::string?

lldb/include/lldb/Target/Target.h

253

What does trampoline "support" mean? Could this be named something more descriptive? From the description of the patch it sounds like this guards whether you step through trampolines, so maybe something like GetEnableStepThroughTrampolines or something?

lldb/source/Core/Module.cpp

779–783

+1 on what Alex said. Also I would either write

bool is_trampoline = Target::GetGlobalProperties().GetEnableTrampolineSupport() && sc.function && !sc.function->IsTrampoline()

or

if (Target::GetGlobalProperties().GetEnableTrampolineSupport()) 
  is_trampoline = sc.function && !sc.function->IsTrampoline();

if you really wanted to split it up

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

2443

The return type of GetTrampolineTargetName isn't obvious from the name so I don't think this is a good place to use auto (in accordance with the LLVM style guide)

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

208–211

No else-after-return. I would write:

return IsValid() ? m_die->GetTrampolineTargetName(m_cu) : nullptr;

211

nvm, I see this is done for consistency with the existing code...

lldb/source/Target/ThreadPlanRunToAddress.cpp

217

This is more of a preference but I would make this const to avoid accidentally modifying this value.

221–222

Not sure how hot this is, but would it be worthwhile moving this out of the loop and reusing the same object for every iteration?

226–232

Nit: I would just inline this. I'm sure the compiler will optimize this for you, but knowing the macro has the same if(log) check, I try avoid wrapping it in if(log).

lldb/source/Target/ThreadPlanStepThrough.cpp

126

Should we check that the current frame is not null?

[augusto2112]

Addressed comments

lldb/include/lldb/Target/Target.h

253

Yeah I agree the name is pretty generic. This guards both stepping and setting breakpoints on trampolines (by name). We could potentially have two different settings (one for stepping on trampolines, one for breakpoints), but at the same time I don't think there are many users who would want to change only of or the other. I'll add a doxygen comment here with the explanation of what this does, but I'd be happy to change the setting name if anyone has a better suggestion.

[augusto2112]

Abandoning in favor of https://reviews.llvm.org/D147292/.

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] trampoline_target
+  ///     The symbol name this function should trampoline to.
   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,
+           llvm::StringRef trampoline_target = {});
 
   /// 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();
 
+  ConstString GetTrampolineTargetName() const {
+    return m_trampoline_target;
+  }
+  
+  bool IsTrampoline() const {
+    return !m_trampoline_target.IsEmpty();
+  }
+
   /// 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;
 
+  /// The symbol name this function should trampoline to.
+  ConstString m_trampoline_target;
+
   /// 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/ThreadPlanRunToAddress.h

public:
   void SetStopOthers(bool new_value) override;
 
   lldb::StateType GetPlanRunState() override;
 
   bool WillStop() override;
 
   bool MischiefManaged() override;
 
+  /// Finds all the addresses the symbol name resolves to, and make a thread
+  /// plan that runs to them.
+  static lldb::ThreadPlanSP
+  MakeThreadPlanRunToAddressFromSymbol(Thread &thread, ConstString symbol_name,
+                                       bool stop_others);
+
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   void SetInitialBreakpoints();
   bool AtOurAddress();
 
 private:
   bool m_stop_others;

lldb/include/lldb/Target/ThreadPlanStepThrough.h

protected:
   bool HitOurBackstopBreakpoint();
 
 private:
   friend lldb::ThreadPlanSP
   Thread::QueueThreadPlanForStepThrough(StackID &return_stack_id,
                                         bool abort_other_plans,
                                         bool stop_others, Status &status);
 
+  lldb::ThreadPlanSP LookForFunctionWithTrampolineTarget();
+
   void ClearBackstopBreakpoint();
 
   lldb::ThreadPlanSP m_sub_plan_sp;
   lldb::addr_t m_start_address;
   lldb::break_id_t m_backstop_bkpt_id;
   lldb::addr_t m_backstop_addr;
   StackID m_return_stack_id;
   bool m_stop_others;

lldb/source/Core/Module.cpp

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;
     while (i < sc_list.GetSize()) {
       if (!sc_list.GetContextAtIndex(i, sc))
         break;
 
+      bool is_trampoline =
+          Target::GetGlobalProperties().GetEnableTrampolineSupport() &&
+          sc.function && sc.function->IsTrampoline();
+
       bool keep_it =
+          !is_trampoline &&
           NameMatchesLookupInfo(sc.GetFunctionName(), sc.GetLanguage());
       if (keep_it)
         ++i;
       else
         sc_list.RemoveContextAtIndex(i);
     }
   }
 

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

DynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread,
 
   if (current_symbol != nullptr) {
     std::vector<Address> addresses;
 
     if (current_symbol->IsTrampoline()) {
       ConstString trampoline_name =
           current_symbol->GetMangled().GetName(Mangled::ePreferMangled);
 
-      if (trampoline_name) {
-        const ModuleList &images = target_sp->GetImages();
-
-        SymbolContextList code_symbols;
-        images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode,
-                                          code_symbols);
-        size_t num_code_symbols = code_symbols.GetSize();
-
-        if (num_code_symbols > 0) {
-          for (uint32_t i = 0; i < num_code_symbols; i++) {
-            SymbolContext context;
-            AddressRange addr_range;
-            if (code_symbols.GetContextAtIndex(i, context)) {
-              context.GetAddressRange(eSymbolContextEverything, 0, false,
-                                      addr_range);
-              addresses.push_back(addr_range.GetBaseAddress());
-              if (log) {
-                addr_t load_addr =
-                    addr_range.GetBaseAddress().GetLoadAddress(target_sp.get());
-
-                LLDB_LOGF(log,
-                          "Found a trampoline target symbol at 0x%" PRIx64 ".",
-                          load_addr);
-              }
-            }
-          }
-        }
-
-        SymbolContextList reexported_symbols;
-        images.FindSymbolsWithNameAndType(
-            trampoline_name, eSymbolTypeReExported, reexported_symbols);
-        size_t num_reexported_symbols = reexported_symbols.GetSize();
-        if (num_reexported_symbols > 0) {
-          for (uint32_t i = 0; i < num_reexported_symbols; i++) {
-            SymbolContext context;
-            if (reexported_symbols.GetContextAtIndex(i, context)) {
-              if (context.symbol) {
-                Symbol *actual_symbol =
-                    context.symbol->ResolveReExportedSymbol(*target_sp.get());
-                if (actual_symbol) {
-                  const Address actual_symbol_addr =
-                      actual_symbol->GetAddress();
-                  if (actual_symbol_addr.IsValid()) {
-                    addresses.push_back(actual_symbol_addr);
-                    if (log) {
-                      lldb::addr_t load_addr =
-                          actual_symbol_addr.GetLoadAddress(target_sp.get());
-                      LLDB_LOGF(
-                          log,
-                          "Found a re-exported symbol: %s at 0x%" PRIx64 ".",
-                          actual_symbol->GetName().GetCString(), load_addr);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        SymbolContextList indirect_symbols;
-        images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeResolver,
-                                          indirect_symbols);
-        size_t num_indirect_symbols = indirect_symbols.GetSize();
-        if (num_indirect_symbols > 0) {
-          for (uint32_t i = 0; i < num_indirect_symbols; i++) {
-            SymbolContext context;
-            AddressRange addr_range;
-            if (indirect_symbols.GetContextAtIndex(i, context)) {
-              context.GetAddressRange(eSymbolContextEverything, 0, false,
-                                      addr_range);
-              addresses.push_back(addr_range.GetBaseAddress());
-              if (log) {
-                addr_t load_addr =
-                    addr_range.GetBaseAddress().GetLoadAddress(target_sp.get());
-
-                LLDB_LOGF(log,
-                          "Found an indirect target symbol at 0x%" PRIx64 ".",
-                          load_addr);
-              }
-            }
-          }
-        }
-      }
+      if (trampoline_name)
+        thread_plan_sp =
+            ThreadPlanRunToAddress::MakeThreadPlanRunToAddressFromSymbol(
+                thread, trampoline_name, stop_others);
     } else if (current_symbol->GetType() == eSymbolTypeReExported) {
       // I am not sure we could ever end up stopped AT a re-exported symbol.
       // But just in case:
 
       const Symbol *actual_symbol =
           current_symbol->ResolveReExportedSymbol(*(target_sp.get()));
       if (actual_symbol) {
         Address target_addr(actual_symbol->GetAddress());

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 char *trampoline_target = die.GetTrampolineTargetName();
+
     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
+                                   trampoline_target);
 
     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;
 
+  const char *GetTrampolineTargetName() 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;
 }
 
+
+const char *DWARFDIE::GetTrampolineTargetName() const {
+  if (IsValid())
+    return m_die->GetTrampolineTargetName(m_cu);
+  else
+    return nullptr;
+}
+
 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;
 
+  const char *GetTrampolineTargetName(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;
 }
 
+const char *
+DWARFDebugInfoEntry::GetTrampolineTargetName(const DWARFUnit *cu) const {
+  return GetAttributeValueAsString(cu, DW_AT_trampoline, nullptr, true);
+}
 // 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,
+                   llvm::StringRef trampoline_target)
     : 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_trampoline_target(trampoline_target),
+      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/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/ThreadPlanRunToAddress.cpp

bool ThreadPlanRunToAddress::AtOurAddress() {
   for (size_t i = 0; i < num_addresses; i++) {
     if (m_addresses[i] == current_address) {
       found_it = true;
       break;
     }
   }
   return found_it;
 }
+
+ThreadPlanSP ThreadPlanRunToAddress::MakeThreadPlanRunToAddressFromSymbol(
+    Thread &thread, ConstString symbol_name, bool stop_others) {
+  TargetSP target_sp(thread.CalculateTarget());
+  if (!target_sp)
+    return {};
+
+  Log *log = GetLog(LLDBLog::Step);
+  std::vector<Address> addresses;
+  const ModuleList &images = target_sp->GetImages();
+
+  SymbolContextList code_symbols;
+  images.FindSymbolsWithNameAndType(symbol_name, eSymbolTypeCode, code_symbols);
+  const size_t num_code_symbols = code_symbols.GetSize();
+
+  if (num_code_symbols > 0) {
+    SymbolContext context;
+    AddressRange addr_range;
+    for (uint32_t i = 0; i < num_code_symbols; i++) {
+      context.Clear(true);
+      if (code_symbols.GetContextAtIndex(i, context)) {
+        addr_range.Clear();
+        context.GetAddressRange(eSymbolContextEverything, 0, false, addr_range);
+        addresses.push_back(addr_range.GetBaseAddress());
+        LLDB_LOG(log, "Found a trampoline target symbol at {0:x}.",
+                 addr_range.GetBaseAddress().GetLoadAddress(target_sp.get()));
+      }
+    }
+  }
+
+  SymbolContextList reexported_symbols;
+  images.FindSymbolsWithNameAndType(symbol_name, eSymbolTypeReExported,
+                                    reexported_symbols);
+  size_t num_reexported_symbols = reexported_symbols.GetSize();
+  if (num_reexported_symbols > 0) {
+    for (uint32_t i = 0; i < num_reexported_symbols; i++) {
+      SymbolContext context;
+      if (reexported_symbols.GetContextAtIndex(i, context)) {
+        if (context.symbol) {
+          Symbol *actual_symbol =
+              context.symbol->ResolveReExportedSymbol(*target_sp.get());
+          if (actual_symbol) {
+            const Address actual_symbol_addr = actual_symbol->GetAddress();
+            if (actual_symbol_addr.IsValid()) {
+              addresses.push_back(actual_symbol_addr);
+              actual_symbol_addr.GetLoadAddress(target_sp.get());
+              LLDB_LOGF(log, "Found a re-exported symbol: %s at 0x%" PRIx64 ".",
+                        actual_symbol->GetName().GetCString(),
+                        actual_symbol_addr.GetLoadAddress(target_sp.get()));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  SymbolContextList indirect_symbols;
+  images.FindSymbolsWithNameAndType(symbol_name, eSymbolTypeResolver,
+                                    indirect_symbols);
+  size_t num_indirect_symbols = indirect_symbols.GetSize();
+  if (num_indirect_symbols > 0) {
+    for (uint32_t i = 0; i < num_indirect_symbols; i++) {
+      SymbolContext context;
+      AddressRange addr_range;
+      if (indirect_symbols.GetContextAtIndex(i, context)) {
+        context.GetAddressRange(eSymbolContextEverything, 0, false, addr_range);
+        addresses.push_back(addr_range.GetBaseAddress());
+        LLDB_LOGF(log, "Found an indirect target symbol at 0x%" PRIx64 ".",
+                  addr_range.GetBaseAddress().GetLoadAddress(target_sp.get()));
+      }
+    }
+  }
+
+  if (addresses.empty())
+    return {};
+
+  // First check whether any of the addresses point to Indirect symbols,
+  // and if they do, resolve them:
+  std::vector<lldb::addr_t> load_addrs;
+  for (Address address : addresses) {
+    Symbol *symbol = address.CalculateSymbolContextSymbol();
+    if (symbol && symbol->IsIndirect()) {
+      Status error;
+      Address symbol_address = symbol->GetAddress();
+      addr_t resolved_addr =
+          thread.GetProcess()->ResolveIndirectFunction(&symbol_address, error);
+      if (error.Success()) {
+        load_addrs.push_back(resolved_addr);
+      }
+    } else {
+      load_addrs.push_back(address.GetLoadAddress(target_sp.get()));
+    }
+  }
+
+  return std::make_shared<ThreadPlanRunToAddress>(thread, load_addrs,
+                                                  stop_others);
+}

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->IsTrampoline())
+      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/ThreadPlanStepThrough.cpp

 //===-- ThreadPlanStepThrough.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/ThreadPlanStepThrough.h"
 #include "lldb/Breakpoint/Breakpoint.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlanStepThrough: If the current instruction is a trampoline, step
 // through it If it is the beginning of the prologue of a function, step
 // through that as well.
 
 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
for (LanguageRuntime *runtime : m_process.GetLanguageRuntimes()) {
       m_sub_plan_sp =
           runtime->GetStepThroughTrampolinePlan(thread, m_stop_others);
 
       if (m_sub_plan_sp)
         break;
     }
   }
 
+  if (!m_sub_plan_sp)
+    m_sub_plan_sp = LookForFunctionWithTrampolineTarget();
+
   Log *log = GetLog(LLDBLog::Step);
   if (log) {
     lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC(0);
     if (m_sub_plan_sp) {
       StreamString s;
       m_sub_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
       LLDB_LOGF(log, "Found step through plan from 0x%" PRIx64 ": %s",
                 current_address, s.GetData());
     } else {
       LLDB_LOGF(log,
                 "Couldn't find step through plan from address 0x%" PRIx64 ".",
                 current_address);
     }
   }
 }
 
+ThreadPlanSP ThreadPlanStepThrough::LookForFunctionWithTrampolineTarget() {
+  Thread &thread = GetThread();
+  TargetSP target_sp(thread.CalculateTarget());
+  if (!target_sp)
+    return {};
+
+  StackFrameSP current_frame = thread.GetStackFrameAtIndex(0);
+  if (!current_frame)
+    return {};
+
+  const SymbolContext &current_context =
+      current_frame->GetSymbolContext(lldb::eSymbolContextFunction);
+  Function *current_function = current_context.function;
+  if (!current_function)
+    return {};
+
+  ConstString trampoline_name =
+      ConstString(current_function->GetTrampolineTargetName());
+  if (trampoline_name.IsEmpty())
+    return {};
+
+  return ThreadPlanRunToAddress::MakeThreadPlanRunToAddressFromSymbol(
+      thread, trampoline_name, m_stop_others);
+  ;
+}
+
 void ThreadPlanStepThrough::GetDescription(Stream *s,
                                            lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief)
     s->Printf("Step through");
   else {
     s->PutCString("Stepping through trampoline code from: ");
     DumpAddress(s->AsRawOstream(), m_start_address, sizeof(addr_t));
     if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {

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_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__((__trampoline__("foo")))
+void bar(void) {
+  foo();
+}
+
+__attribute__((__trampoline__("bar")))
+void baz(void) {
+  bar();
+}
+
+__attribute__((__trampoline__("bar")))
+void doesnt_call_trampoline(void) {
+  int a = 2;
+  int b = 3;
+  int c = a + b;
+}
+
+
+void direct_trampoline_call(void) {
+  bar(); // Break here for direct 
+  bar();
+}
+
+void chained_trampoline_call(void) {
+  baz(); // Break here for chained
+  baz();
+}
+
+void unused_target(void) {
+  doesnt_call_trampoline(); // Break here for unused
+}
+
+int main(void) {
+  direct_trampoline_call();
+  chained_trampoline_call();
+  unused_target();
+  return 0;
+}
+