[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

Author: augusto2112

lldb/include/lldb/Symbol/Function.h

@@ -436,9 +436,14 @@ class Function : public UserID, public SymbolContextScope {
   ///
   /// \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;
@@ -550,6 +555,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.
   ///
@@ -650,6 +659,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

@@ -250,6 +250,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

@@ -897,6 +897,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

@@ -776,7 +776,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

@@ -2440,12 +2440,15 @@ 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
+                                   is_generic_trampoline);
 
     if (func_sp.get() != nullptr) {
       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);