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

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).

Differential Revision: https://reviews.llvm.org/D147292

(cherry picked from commit 4a8e545)

Author: augusto2112

lldb/include/lldb/Symbol/Function.h

@@ -442,7 +442,7 @@ class Function : public UserID, public SymbolContextScope {
   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,
-           bool can_throw = false);
+           bool can_throw = false, bool generic_trampoline = false);
 
   /// Destructor.
   ~Function() override;
@@ -554,6 +554,10 @@ class Function : public UserID, public SymbolContextScope {
   ///     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.
   ///
@@ -659,6 +663,8 @@ class Function : public UserID, public SymbolContextScope {
   /// information.
   Mangled m_mangled;
 
+  bool m_is_generic_trampoline;
+
   /// All lexical blocks contained in this function.
   Block m_block;
 

lldb/include/lldb/Target/Target.h

@@ -289,6 +289,12 @@ class TargetProperties : public Properties {
 
   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();

lldb/include/lldb/Target/Thread.h

@@ -904,6 +904,27 @@ class Thread : public std::enable_shared_from_this<Thread>,
                                 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.

lldb/include/lldb/Target/ThreadPlan.h

@@ -302,6 +302,7 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
     eKindStepInRange,
     eKindRunToAddress,
     eKindStepThrough,
+    eKindStepThroughGenericTrampoline,
     eKindStepUntil
   };
 

lldb/include/lldb/Target/ThreadPlanStepOverRange.h

@@ -30,7 +30,6 @@ class ThreadPlanStepOverRange : public ThreadPlanStepRange,
   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 {

lldb/include/lldb/Target/ThreadPlanStepRange.h

@@ -41,6 +41,7 @@ class ThreadPlanStepRange : public ThreadPlan {
   void AddRange(const AddressRange &new_range);
 
 protected:
+  bool DoPlanExplainsStop(Event *event_ptr) override;
   bool InRange();
   lldb::FrameComparison CompareCurrentFrameToStartFrame();
   bool InSymbol();

lldb/include/lldb/Target/ThreadPlanStepThroughGenericTrampoline.h

@@ -0,0 +1,52 @@
+//===-- 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

@@ -799,7 +799,12 @@ void Module::LookupInfo::Prune(SymbolContextList &sc_list,
       if (!sc_list.GetContextAtIndex(i, sc))
         break;
 
+      bool is_trampoline =
+          Target::GetGlobalProperties().GetEnableTrampolineSupport() &&
+          sc.function && sc.function->IsGenericTrampoline();
+
       bool keep_it =
+          !is_trampoline &&
           NameMatchesLookupInfo(sc.GetFunctionName(), sc.GetLanguage());
       if (keep_it)
         ++i;

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

@@ -2395,12 +2395,16 @@ DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
 
     assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
+    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
+                                   false, // canThrow
+                                   is_generic_trampoline);
 
     if (func_sp.get() != nullptr) {
       if (frame_base.IsValid())

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

@@ -274,9 +274,11 @@ Function *DWARFASTParserSwift::ParseFunctionFromDWARF(
           decl_column));
 
     const user_id_t func_user_id = die.GetID();
+    bool is_generic_trampoline = die.IsGenericTrampoline();
     func_sp.reset(new Function(&comp_unit, func_user_id, func_user_id,
-                               func_name, nullptr, func_range,
-                               can_throw)); // first address range
+                               func_name, nullptr,
+                               func_range, // first address range
+                               can_throw, is_generic_trampoline));
 
     if (func_sp.get() != NULL) {
       if (frame_base.IsValid())

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

@@ -203,6 +203,13 @@ const char *DWARFDIE::GetMangledName() const {
     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);

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

@@ -28,6 +28,8 @@ class DWARFDIE : public DWARFBaseDIE {
   // Accessing information about a DIE
   const char *GetMangledName() const;
 
+  bool IsGenericTrampoline() const;
+
   const char *GetPubname() const;
 
   const char *GetQualifiedName(std::string &storage) const;

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

@@ -679,6 +679,12 @@ DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu,
   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

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

@@ -97,6 +97,8 @@ class DWARFDebugInfoEntry {
   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;
 
   const char *GetQualifiedName(DWARFUnit *cu, std::string &storage) const;

lldb/source/Symbol/Function.cpp

@@ -233,10 +233,11 @@ Function *IndirectCallEdge::GetCallee(ModuleList &images,
 //
 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, bool canThrow)
+                   const AddressRange &range, bool canThrow, 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);
   if (canThrow)
     m_flags.Set(flagsFunctionCanThrow);

lldb/source/Target/CMakeLists.txt

@@ -65,6 +65,7 @@ add_lldb_library(lldbTarget
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
+  ThreadPlanStepThroughGenericTrampoline.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp

lldb/source/Target/Target.cpp

@@ -5305,6 +5305,12 @@ bool TargetProperties::GetDebugUtilityExpression() const {
       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);

lldb/source/Target/TargetProperties.td

@@ -218,6 +218,9 @@ let Definition = "target" in {
   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 {

lldb/source/Target/Thread.cpp

@@ -41,6 +41,7 @@
 #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"
@@ -1419,6 +1420,17 @@ ThreadPlanSP Thread::QueueThreadPlanForStepThrough(StackID &return_stack_id,
   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,

lldb/source/Target/ThreadPlanShouldStopHere.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ThreadPlanShouldStopHere.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
@@ -96,10 +97,16 @@ bool ThreadPlanShouldStopHere::DefaultShouldStopHereCallback(
   // 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)
+  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;
   }
 

lldb/source/Target/ThreadPlanStepInRange.cpp

@@ -221,6 +221,17 @@ bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) {
 
     // 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);

lldb/source/Target/ThreadPlanStepOverRange.cpp

@@ -334,37 +334,6 @@ bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) {
     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) {