FuncUnwinders: Add a new "SymbolFile" unwind plan

[labath]

Summary

some unwind formats are specific to a single symbol file and so it does
not make sense for their parsing code live in the general Symbol library
(as is the case with eh_frame for instance). This is the case for the
unwind information in breakpad files, but the same will probably be true
for PDB unwind info (once we are able to parse that).

This patch adds the ability to fetch an unwind plan provided by a symbol
file plugin, as discussed in the RFC at
http://lists.llvm.org/pipermail/lldb-dev/2019-February/014703.html.
I've kept the set of changes to a minimum, as there is no way to test
them until we have a symbol file which implements this API -- that is
comming in a follow-up patch, which will also implicitly test this
change.

The interesting part here is the introduction of the
"RegisterInfoResolver" interface. The reason for this is that breakpad
needs to be able to resolve register names (which are present as strings
in the file) into register enums so that it can construct the unwind
plan. This is normally done via the RegisterContext class, handing this
over to the SymbolFile plugin would mean that it has full access to the
debugged process, which is not something we want it to have. So instead,
I create a facade, which only provides the ability to query register
names, and hide the RegisterContext behind the facade.

Also note that this only adds the ability to dump the unwind plan
created by the symbol file plugin -- the plan is not used for unwinding
yet -- this will be added in a third patch, which will add additional
tests which makes sure the unwinding works as a whole.

[clayborg]

Looks good except the inline comment about all the unwind plans we have now. Would love to simplify this so that EH frame, compact unwind, ARM unwind, breakpad unwind all come from the symbol file or object files. Also be nice to have a register resolver that works without having a process so we can dump unwind info without needing a process.

include/lldb/Symbol/FuncUnwinders.h

123–125

Seems like the compact unwind should move into the ObjectFileMachO and ARM unwind should move into ObjectFileELF as part of this? We have so many unwind plans here, the logic is already too complex around the selection process. Seems like m_unwind_plan_compact_unwind, m_unwind_plan_arm_unwind_sp, and possibly even m_unwind_plan_eh_frame_augmented_sp and m_unwind_plan_debug_frame_augmented_sp should all be moved into the ObjectFile classes so they can be accessed by the symbol file. This will allow say ObjectFileMachO to determine which is the best to use for a given address, and also ObjectFileELF.

[labath]

In D61732#1496575, @clayborg wrote:

Looks good except the inline comment about all the unwind plans we have now. Would love to simplify this so that EH frame, compact unwind, ARM unwind, breakpad unwind all come from the symbol file or object files. Also be nice to have a register resolver that works without having a process so we can dump unwind info without needing a process.

I was also considering that (making unwind plan providers more pluggable), but I gave up after a day or two of experimenting. As I recall, the main problem was that there are places in code that go straight for a specific unwind plan instead of just asking for a "(non)call site unwind plan". Some of those use cases are relatively reasonable: e.g. one can ask for an eh_frame unwind plan even if he does know the exact symbol and it's boundaries where he's stopped at, but that is definitely not the case for the "instruction emulation" plan.

It wasn't clear to me how to reconcile these requirements, so I just went with the approach that preserves status quo. Given that most of these unwind plans are not tied to a specific object/symbol file format (I didn't realize that compact unwind is specific to mach-o), encapsulating them inside a plugin did not seem to be that important.

The thing that could help with the readability here is to avoid having a separate shared_ptr for the plan, and a bool flag for whether we attempted to create the plan. Encapsulating that into a single entity would go a long way towards making this class more readable, but it would also increase the size of this class (i'm not sure how much we care about that). There are also ways to do that without increasing the size (or even with decreasing it), but they would all be more or less magical, which I wasn't sure whether is worth it.

I definitely plan to look into making unwind plan computation possible without a running process but that will require us to get a different source of truth for the register eh/dwarf numbers (right now we get those from the remote stub), which is not going to be an easy task.

[jasonmolenda]

Looks good to me.

Yes, we need to change from a model of "the remote stub teaches lldb everything about registers" to "lldb knows all the architectural / ABI register number details, asks the remote stub what numbers it uses for them when connected". The need to go through RegisterContext::ConvertBetweenRegisterKinds / RegisterContext::GetRegisterInfoAtIndex to get any information about registers is unfortunate.

I'm not super concerned about the size of the UnwindPlan or FuncUnwinders objects - we create them lazily as we unwind through functions in the process, so my guess is that even a long-running debug session will have on the order of thousands of these objects. The ABIs don't even bother to issue a single ArchDefault unwind plan and FunctionEntry unwind plan, handing out a new one for each FuncUnwinders object (ok that part is a little embarrassing, but again this isn't super high on the priority list to fix imo.)

[labath]

In D61732#1497609, @jasonmolenda wrote:

I'm not super concerned about the size of the UnwindPlan or FuncUnwinders objects - we create them lazily as we unwind through functions in the process, so my guess is that even a long-running debug session will have on the order of thousands of these objects. The ABIs don't even bother to issue a single ArchDefault unwind plan and FunctionEntry unwind plan, handing out a new one for each FuncUnwinders object (ok that part is a little embarrassing, but again this isn't super high on the priority list to fix imo.)

Ok, sounds good. I'll whip up a patch to merge the _sp and _tried fields into one entity.

include/lldb/Symbol/FuncUnwinders.h

public:
 
   lldb::UnwindPlanSP GetDebugFrameAugmentedUnwindPlan(Target &target,
                                                       Thread &thread);
 
   lldb::UnwindPlanSP GetCompactUnwindUnwindPlan(Target &target);
 
   lldb::UnwindPlanSP GetArmUnwindUnwindPlan(Target &target);
 
+  lldb::UnwindPlanSP GetSymbolFileUnwindPlan(Thread &thread);
+
   lldb::UnwindPlanSP GetArchDefaultUnwindPlan(Thread &thread);
 
   lldb::UnwindPlanSP GetArchDefaultAtFuncEntryUnwindPlan(Thread &thread);
 
 private:
   lldb::UnwindAssemblySP GetUnwindAssemblyProfiler(Target &target);
 
   // Do a simplistic comparison for the register restore rule for getting the
private:
   lldb::UnwindPlanSP m_unwind_plan_assembly_sp;
   lldb::UnwindPlanSP m_unwind_plan_eh_frame_sp;
   lldb::UnwindPlanSP m_unwind_plan_debug_frame_sp;
 
   // augmented by assembly inspection so it's valid everywhere
   lldb::UnwindPlanSP m_unwind_plan_eh_frame_augmented_sp;
   lldb::UnwindPlanSP m_unwind_plan_debug_frame_augmented_sp;
 
   std::vector<lldb::UnwindPlanSP> m_unwind_plan_compact_unwind;
   lldb::UnwindPlanSP m_unwind_plan_arm_unwind_sp;
+  lldb::UnwindPlanSP m_unwind_plan_symbol_file_sp;
   lldb::UnwindPlanSP m_unwind_plan_fast_sp;
   lldb::UnwindPlanSP m_unwind_plan_arch_default_sp;
   lldb::UnwindPlanSP m_unwind_plan_arch_default_at_func_entry_sp;
 
   // Fetching the UnwindPlans can be expensive - if we've already attempted to
   // get one & failed, don't try again.
   bool m_tried_unwind_plan_assembly : 1, m_tried_unwind_plan_eh_frame : 1,
       m_tried_unwind_plan_debug_frame : 1,
       m_tried_unwind_plan_eh_frame_augmented : 1,
       m_tried_unwind_plan_debug_frame_augmented : 1,
       m_tried_unwind_plan_compact_unwind : 1,
-      m_tried_unwind_plan_arm_unwind : 1, m_tried_unwind_fast : 1,
-      m_tried_unwind_arch_default : 1,
+      m_tried_unwind_plan_arm_unwind : 1, m_tried_unwind_plan_symbol_file : 1,
+      m_tried_unwind_fast : 1, m_tried_unwind_arch_default : 1,
       m_tried_unwind_arch_default_at_func_entry : 1;
 
   Address m_first_non_prologue_insn;
 
   DISALLOW_COPY_AND_ASSIGN(FuncUnwinders);
 
 }; // class FuncUnwinders
 
 } // namespace lldb_private
 
 #endif // liblldb_FuncUnwinders_h

include/lldb/Symbol/SymbolFile.h

public:
   }
 
   virtual void AddSymbols(Symtab &symtab) {}
 
   /// Notify the SymbolFile that the file addresses in the Sections
   /// for this module have been changed.
   virtual void SectionFileAddressesChanged() {}
 
+  struct RegisterInfoResolver {
+    virtual ~RegisterInfoResolver(); // anchor
+
+    virtual const RegisterInfo *ResolveName(llvm::StringRef name) const = 0;
+    virtual const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
+                                              uint32_t number) const = 0;
+  };
+  virtual lldb::UnwindPlanSP
+  GetUnwindPlan(const Address &address, const RegisterInfoResolver &resolver) {
+    return nullptr;
+  }
+
   virtual void Dump(Stream &s) {}
 
 protected:
   void AssertModuleLock();
 
   ObjectFile *m_obj_file; // The object file that symbols can be extracted from.
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolFile_h_

include/lldb/Symbol/UnwindTable.h

public:
   ~UnwindTable();
 
   lldb_private::DWARFCallFrameInfo *GetEHFrameInfo();
   lldb_private::DWARFCallFrameInfo *GetDebugFrameInfo();
 
   lldb_private::CompactUnwindInfo *GetCompactUnwindInfo();
 
   ArmUnwindInfo *GetArmUnwindInfo();
+  SymbolFile *GetSymbolFile();
 
   lldb::FuncUnwindersSP GetFuncUnwindersContainingAddress(const Address &addr,
                                                           SymbolContext &sc);
 
   bool GetAllowAssemblyEmulationUnwindPlans();
 
   // Normally when we create a new FuncUnwinders object we track it in this
   // UnwindTable so it can be reused later.  But for the target modules show-

source/Commands/CommandObjectTarget.cpp

for (uint32_t idx = 0; idx < num_matches; idx++) {
           func_unwinders_sp->GetArmUnwindUnwindPlan(*target);
       if (arm_unwind_sp) {
         result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n");
         arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
                             LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }
 
+      if (UnwindPlanSP symfile_plan_sp =
+              func_unwinders_sp->GetSymbolFileUnwindPlan(*thread)) {
+        result.GetOutputStream().Printf("Symbol file UnwindPlan:\n");
+        symfile_plan_sp->Dump(result.GetOutputStream(), thread.get(),
+                              LLDB_INVALID_ADDRESS);
+        result.GetOutputStream().Printf("\n");
+      }
+
       UnwindPlanSP compact_unwind_sp =
           func_unwinders_sp->GetCompactUnwindUnwindPlan(*target);
       if (compact_unwind_sp) {
         result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n");
         compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
                                 LLDB_INVALID_ADDRESS);
         result.GetOutputStream().Printf("\n");
       }

source/Symbol/FuncUnwinders.cpp

 //===-- FuncUnwinders.cpp ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/RegisterNumber.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnwindAssembly.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 /// constructor
 
 FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
     : m_unwind_table(unwind_table), m_range(range), m_mutex(),
       m_unwind_plan_assembly_sp(), m_unwind_plan_eh_frame_sp(),
       m_unwind_plan_eh_frame_augmented_sp(), m_unwind_plan_compact_unwind(),
       m_unwind_plan_arm_unwind_sp(), m_unwind_plan_fast_sp(),
       m_unwind_plan_arch_default_sp(),
       m_unwind_plan_arch_default_at_func_entry_sp(),
       m_tried_unwind_plan_assembly(false), m_tried_unwind_plan_eh_frame(false),
       m_tried_unwind_plan_debug_frame(false),
       m_tried_unwind_plan_eh_frame_augmented(false),
       m_tried_unwind_plan_debug_frame_augmented(false),
       m_tried_unwind_plan_compact_unwind(false),
-      m_tried_unwind_plan_arm_unwind(false), m_tried_unwind_fast(false),
+      m_tried_unwind_plan_arm_unwind(false),
+      m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false),
       m_tried_unwind_arch_default(false),
       m_tried_unwind_arch_default_at_func_entry(false),
       m_first_non_prologue_insn() {}
 
 /// destructor
 
 FuncUnwinders::~FuncUnwinders() {}
 
if (arm_unwind_info) {
       if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
                                           *m_unwind_plan_arm_unwind_sp))
         m_unwind_plan_arm_unwind_sp.reset();
     }
   }
   return m_unwind_plan_arm_unwind_sp;
 }
 
+namespace {
+class RegisterContextToInfo: public SymbolFile::RegisterInfoResolver {
+public:
+  RegisterContextToInfo(RegisterContext &ctx) : m_ctx(ctx) {}
+
+  const RegisterInfo *ResolveName(llvm::StringRef name) const {
+    return m_ctx.GetRegisterInfoByName(name);
+  }
+  const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
+                                    uint32_t number) const {
+    return m_ctx.GetRegisterInfo(kind, number);
+  }
+
+private:
+  RegisterContext &m_ctx;
+};
+} // namespace
+
+UnwindPlanSP FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_unwind_plan_symbol_file_sp.get() || m_tried_unwind_plan_symbol_file)
+    return m_unwind_plan_symbol_file_sp;
+
+  m_tried_unwind_plan_symbol_file = true;
+  if (SymbolFile *symfile = m_unwind_table.GetSymbolFile()) {
+    m_unwind_plan_symbol_file_sp = symfile->GetUnwindPlan(
+        m_range.GetBaseAddress(),
+        RegisterContextToInfo(*thread.GetRegisterContext()));
+  }
+  return m_unwind_plan_symbol_file_sp;
+}
+
 UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
                                                           Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_eh_frame_augmented_sp.get() ||
       m_tried_unwind_plan_eh_frame_augmented)
     return m_unwind_plan_eh_frame_augmented_sp;
 
   // Only supported on x86 architectures where we get eh_frame from the

source/Symbol/SymbolFile.cpp

#if defined(LLDB_CONFIGURATION_DEBUG)
   // different thread. Note that we must abort if the result is true to
   // guarantee correctness.
   assert(std::async(std::launch::async,
                     [this] { return this->GetModuleMutex().try_lock(); })
                  .get() == false &&
          "Module is not locked");
 #endif
 }
+
+SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;

source/Symbol/UnwindTable.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolVendor.h"
 
 // There is one UnwindTable object per ObjectFile. It contains a list of Unwind
 // objects -- one per function, populated lazily -- for the ObjectFile. Each
 // Unwind object has multiple UnwindPlans for different scenarios.
 
 using namespace lldb;
 using namespace lldb_private;
 
CompactUnwindInfo *UnwindTable::GetCompactUnwindInfo() {
   return m_compact_unwind_up.get();
 }
 
 ArmUnwindInfo *UnwindTable::GetArmUnwindInfo() {
   Initialize();
   return m_arm_unwind_up.get();
 }
 
+SymbolFile *UnwindTable::GetSymbolFile() {
+  if (SymbolVendor *vendor = m_module.GetSymbolVendor())
+    return vendor->GetSymbolFile();
+  return nullptr;
+}
+
 ArchSpec UnwindTable::GetArchitecture() { return m_module.GetArchitecture(); }
 
 bool UnwindTable::GetAllowAssemblyEmulationUnwindPlans() {
   if (ObjectFile *object_file = m_module.GetObjectFile())
     return object_file->AllowAssemblyEmulationUnwindPlans();
   return false;
 }