lldb/source/Symbol/FuncUnwinders.cpp

   1 //===-- FuncUnwinders.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Symbol/FuncUnwinders.h"
  10 #include "lldb/Core/Address.h"
  11 #include "lldb/Core/AddressRange.h"
  12 #include "lldb/Symbol/ArmUnwindInfo.h"
  13 #include "lldb/Symbol/CallFrameInfo.h"
  14 #include "lldb/Symbol/CompactUnwindInfo.h"
  15 #include "lldb/Symbol/DWARFCallFrameInfo.h"
  16 #include "lldb/Symbol/ObjectFile.h"
  17 #include "lldb/Symbol/SymbolFile.h"
  18 #include "lldb/Symbol/UnwindPlan.h"
  19 #include "lldb/Symbol/UnwindTable.h"
  20 #include "lldb/Target/ABI.h"
  21 #include "lldb/Target/ExecutionContext.h"
  22 #include "lldb/Target/Process.h"
  23 #include "lldb/Target/RegisterContext.h"
  24 #include "lldb/Target/RegisterNumber.h"
  25 #include "lldb/Target/Target.h"
  26 #include "lldb/Target/Thread.h"
  27 #include "lldb/Target/UnwindAssembly.h"
  28
  29 #include <memory>
  30
  31 using namespace lldb;
  32 using namespace lldb_private;
  33
  34 /// constructor
  35
  36 FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
  37     : m_unwind_table(unwind_table), m_range(range), m_mutex(),
  38       m_unwind_plan_assembly_sp(), m_unwind_plan_eh_frame_sp(),
  39       m_unwind_plan_eh_frame_augmented_sp(), m_unwind_plan_compact_unwind(),
  40       m_unwind_plan_arm_unwind_sp(), m_unwind_plan_fast_sp(),
  41       m_unwind_plan_arch_default_sp(),
  42       m_unwind_plan_arch_default_at_func_entry_sp(),
  43       m_tried_unwind_plan_assembly(false), m_tried_unwind_plan_eh_frame(false),
  44       m_tried_unwind_plan_object_file(false),
  45       m_tried_unwind_plan_debug_frame(false),
  46       m_tried_unwind_plan_object_file_augmented(false),
  47       m_tried_unwind_plan_eh_frame_augmented(false),
  48       m_tried_unwind_plan_debug_frame_augmented(false),
  49       m_tried_unwind_plan_compact_unwind(false),
  50       m_tried_unwind_plan_arm_unwind(false),
  51       m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false),
  52       m_tried_unwind_arch_default(false),
  53       m_tried_unwind_arch_default_at_func_entry(false),
  54       m_first_non_prologue_insn() {}
  55
  56 /// destructor
  57
  58 FuncUnwinders::~FuncUnwinders() = default;
  59
  60 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target,
  61                                                     Thread &thread) {
  62   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  63
  64   if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target))
  65     return plan_sp;
  66   if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))
  67     return plan_sp;
  68   if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target))
  69     return plan_sp;
  70   if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target))
  71     return plan_sp;
  72   if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target))
  73     return plan_sp;
  74   if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target))
  75     return plan_sp;
  76
  77   return nullptr;
  78 }
  79
  80 UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) {
  81   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  82   if (m_unwind_plan_compact_unwind.size() > 0)
  83     return m_unwind_plan_compact_unwind[0]; // FIXME support multiple compact
  84                                             // unwind plans for one func
  85   if (m_tried_unwind_plan_compact_unwind)
  86     return UnwindPlanSP();
  87
  88   m_tried_unwind_plan_compact_unwind = true;
  89   if (m_range.GetBaseAddress().IsValid()) {
  90     Address current_pc(m_range.GetBaseAddress());
  91     CompactUnwindInfo *compact_unwind = m_unwind_table.GetCompactUnwindInfo();
  92     if (compact_unwind) {
  93       UnwindPlanSP unwind_plan_sp(new UnwindPlan(lldb::eRegisterKindGeneric));
  94       if (compact_unwind->GetUnwindPlan(target, current_pc, *unwind_plan_sp)) {
  95         m_unwind_plan_compact_unwind.push_back(unwind_plan_sp);
  96         return m_unwind_plan_compact_unwind[0]; // FIXME support multiple
  97                                                 // compact unwind plans for one
  98                                                 // func
  99       }
 100     }
 101   }
 102   return UnwindPlanSP();
 103 }
 104
 105 lldb::UnwindPlanSP FuncUnwinders::GetObjectFileUnwindPlan(Target &target) {
 106   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 107   if (m_unwind_plan_object_file_sp.get() ||
 108       m_tried_unwind_plan_object_file)
 109     return m_unwind_plan_object_file_sp;
 110
 111   m_tried_unwind_plan_object_file = true;
 112   if (m_range.GetBaseAddress().IsValid()) {
 113     CallFrameInfo *object_file_frame = m_unwind_table.GetObjectFileUnwindInfo();
 114     if (object_file_frame) {
 115       m_unwind_plan_object_file_sp =
 116           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 117       if (!object_file_frame->GetUnwindPlan(m_range,
 118                                             *m_unwind_plan_object_file_sp))
 119         m_unwind_plan_object_file_sp.reset();
 120     }
 121   }
 122   return m_unwind_plan_object_file_sp;
 123 }
 124
 125 UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
 126   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 127   if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
 128     return m_unwind_plan_eh_frame_sp;
 129
 130   m_tried_unwind_plan_eh_frame = true;
 131   if (m_range.GetBaseAddress().IsValid()) {
 132     DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
 133     if (eh_frame) {
 134       m_unwind_plan_eh_frame_sp =
 135           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 136       if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
 137         m_unwind_plan_eh_frame_sp.reset();
 138     }
 139   }
 140   return m_unwind_plan_eh_frame_sp;
 141 }
 142
 143 UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
 144   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 145   if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
 146     return m_unwind_plan_debug_frame_sp;
 147
 148   m_tried_unwind_plan_debug_frame = true;
 149   if (m_range.GetBaseAddress().IsValid()) {
 150     DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
 151     if (debug_frame) {
 152       m_unwind_plan_debug_frame_sp =
 153           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 154       if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
 155         m_unwind_plan_debug_frame_sp.reset();
 156     }
 157   }
 158   return m_unwind_plan_debug_frame_sp;
 159 }
 160
 161 UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) {
 162   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 163   if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
 164     return m_unwind_plan_arm_unwind_sp;
 165
 166   m_tried_unwind_plan_arm_unwind = true;
 167   if (m_range.GetBaseAddress().IsValid()) {
 168     Address current_pc(m_range.GetBaseAddress());
 169     ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
 170     if (arm_unwind_info) {
 171       m_unwind_plan_arm_unwind_sp =
 172           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 173       if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
 174                                           *m_unwind_plan_arm_unwind_sp))
 175         m_unwind_plan_arm_unwind_sp.reset();
 176     }
 177   }
 178   return m_unwind_plan_arm_unwind_sp;
 179 }
 180
 181 namespace {
 182 class RegisterContextToInfo: public SymbolFile::RegisterInfoResolver {
 183 public:
 184   RegisterContextToInfo(RegisterContext &ctx) : m_ctx(ctx) {}
 185
 186   const RegisterInfo *ResolveName(llvm::StringRef name) const override {
 187     return m_ctx.GetRegisterInfoByName(name);
 188   }
 189   const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
 190                                     uint32_t number) const override {
 191     return m_ctx.GetRegisterInfo(kind, number);
 192   }
 193
 194 private:
 195   RegisterContext &m_ctx;
 196 };
 197 } // namespace
 198
 199 UnwindPlanSP FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) {
 200   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 201   if (m_unwind_plan_symbol_file_sp.get() || m_tried_unwind_plan_symbol_file)
 202     return m_unwind_plan_symbol_file_sp;
 203
 204   m_tried_unwind_plan_symbol_file = true;
 205   if (SymbolFile *symfile = m_unwind_table.GetSymbolFile()) {
 206     m_unwind_plan_symbol_file_sp = symfile->GetUnwindPlan(
 207         m_range.GetBaseAddress(),
 208         RegisterContextToInfo(*thread.GetRegisterContext()));
 209   }
 210   return m_unwind_plan_symbol_file_sp;
 211 }
 212
 213 UnwindPlanSP
 214 FuncUnwinders::GetObjectFileAugmentedUnwindPlan(Target &target,
 215                                                      Thread &thread) {
 216   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 217   if (m_unwind_plan_object_file_augmented_sp.get() ||
 218       m_tried_unwind_plan_object_file_augmented)
 219     return m_unwind_plan_object_file_augmented_sp;
 220
 221   m_tried_unwind_plan_object_file_augmented = true;
 222
 223   UnwindPlanSP object_file_unwind_plan = GetObjectFileUnwindPlan(target);
 224   if (!object_file_unwind_plan)
 225     return m_unwind_plan_object_file_augmented_sp;
 226
 227   m_unwind_plan_object_file_augmented_sp =
 228       std::make_shared<UnwindPlan>(*object_file_unwind_plan);
 229
 230   // Augment the instructions with epilogue descriptions if necessary
 231   // so the UnwindPlan can be used at any instruction in the function.
 232
 233   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 234   if (assembly_profiler_sp) {
 235     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
 236             m_range, thread, *m_unwind_plan_object_file_augmented_sp)) {
 237       m_unwind_plan_object_file_augmented_sp.reset();
 238     }
 239   } else {
 240     m_unwind_plan_object_file_augmented_sp.reset();
 241   }
 242   return m_unwind_plan_object_file_augmented_sp;
 243 }
 244
 245 UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
 246                                                           Thread &thread) {
 247   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 248   if (m_unwind_plan_eh_frame_augmented_sp.get() ||
 249       m_tried_unwind_plan_eh_frame_augmented)
 250     return m_unwind_plan_eh_frame_augmented_sp;
 251
 252   // Only supported on x86 architectures where we get eh_frame from the
 253   // compiler that describes the prologue instructions perfectly, and sometimes
 254   // the epilogue instructions too.
 255   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
 256       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
 257       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
 258     m_tried_unwind_plan_eh_frame_augmented = true;
 259     return m_unwind_plan_eh_frame_augmented_sp;
 260   }
 261
 262   m_tried_unwind_plan_eh_frame_augmented = true;
 263
 264   UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target);
 265   if (!eh_frame_plan)
 266     return m_unwind_plan_eh_frame_augmented_sp;
 267
 268   m_unwind_plan_eh_frame_augmented_sp =
 269       std::make_shared<UnwindPlan>(*eh_frame_plan);
 270
 271   // Augment the eh_frame instructions with epilogue descriptions if necessary
 272   // so the UnwindPlan can be used at any instruction in the function.
 273
 274   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 275   if (assembly_profiler_sp) {
 276     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
 277             m_range, thread, *m_unwind_plan_eh_frame_augmented_sp)) {
 278       m_unwind_plan_eh_frame_augmented_sp.reset();
 279     }
 280   } else {
 281     m_unwind_plan_eh_frame_augmented_sp.reset();
 282   }
 283   return m_unwind_plan_eh_frame_augmented_sp;
 284 }
 285
 286 UnwindPlanSP FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target,
 287                                                              Thread &thread) {
 288   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 289   if (m_unwind_plan_debug_frame_augmented_sp.get() ||
 290       m_tried_unwind_plan_debug_frame_augmented)
 291     return m_unwind_plan_debug_frame_augmented_sp;
 292
 293   // Only supported on x86 architectures where we get debug_frame from the
 294   // compiler that describes the prologue instructions perfectly, and sometimes
 295   // the epilogue instructions too.
 296   if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
 297       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
 298       target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
 299     m_tried_unwind_plan_debug_frame_augmented = true;
 300     return m_unwind_plan_debug_frame_augmented_sp;
 301   }
 302
 303   m_tried_unwind_plan_debug_frame_augmented = true;
 304
 305   UnwindPlanSP debug_frame_plan = GetDebugFrameUnwindPlan(target);
 306   if (!debug_frame_plan)
 307     return m_unwind_plan_debug_frame_augmented_sp;
 308
 309   m_unwind_plan_debug_frame_augmented_sp =
 310       std::make_shared<UnwindPlan>(*debug_frame_plan);
 311
 312   // Augment the debug_frame instructions with epilogue descriptions if
 313   // necessary so the UnwindPlan can be used at any instruction in the
 314   // function.
 315
 316   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 317   if (assembly_profiler_sp) {
 318     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
 319             m_range, thread, *m_unwind_plan_debug_frame_augmented_sp)) {
 320       m_unwind_plan_debug_frame_augmented_sp.reset();
 321     }
 322   } else
 323     m_unwind_plan_debug_frame_augmented_sp.reset();
 324   return m_unwind_plan_debug_frame_augmented_sp;
 325 }
 326
 327 UnwindPlanSP FuncUnwinders::GetAssemblyUnwindPlan(Target &target,
 328                                                   Thread &thread) {
 329   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 330   if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
 331       !m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
 332     return m_unwind_plan_assembly_sp;
 333   }
 334
 335   m_tried_unwind_plan_assembly = true;
 336
 337   // Don't analyze more than 10 megabytes of instructions,
 338   // if a function is legitimately larger than that, we'll
 339   // miss the epilogue instructions, but guard against a
 340   // bogusly large function and analyzing large amounts of
 341   // non-instruction data.
 342   AddressRange range = m_range;
 343   const addr_t func_size =
 344       std::min(range.GetByteSize(), (addr_t)1024 * 10 * 10);
 345   range.SetByteSize(func_size);
 346
 347   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 348   if (assembly_profiler_sp) {
 349     m_unwind_plan_assembly_sp =
 350         std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 351     if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
 352             range, thread, *m_unwind_plan_assembly_sp)) {
 353       m_unwind_plan_assembly_sp.reset();
 354     }
 355   }
 356   return m_unwind_plan_assembly_sp;
 357 }
 358
 359 // This method compares the pc unwind rule in the first row of two UnwindPlans.
 360 // If they have the same way of getting the pc value (e.g. "CFA - 8" + "CFA is
 361 // sp"), then it will return LazyBoolTrue.
 362 LazyBool FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation(
 363     Thread &thread, const UnwindPlanSP &a, const UnwindPlanSP &b) {
 364   LazyBool plans_are_identical = eLazyBoolCalculate;
 365
 366   RegisterNumber pc_reg(thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 367   uint32_t pc_reg_lldb_regnum = pc_reg.GetAsKind(eRegisterKindLLDB);
 368
 369   if (a.get() && b.get()) {
 370     UnwindPlan::RowSP a_first_row = a->GetRowAtIndex(0);
 371     UnwindPlan::RowSP b_first_row = b->GetRowAtIndex(0);
 372
 373     if (a_first_row.get() && b_first_row.get()) {
 374       UnwindPlan::Row::AbstractRegisterLocation a_pc_regloc;
 375       UnwindPlan::Row::AbstractRegisterLocation b_pc_regloc;
 376
 377       a_first_row->GetRegisterInfo(pc_reg_lldb_regnum, a_pc_regloc);
 378       b_first_row->GetRegisterInfo(pc_reg_lldb_regnum, b_pc_regloc);
 379
 380       plans_are_identical = eLazyBoolYes;
 381
 382       if (a_first_row->GetCFAValue() != b_first_row->GetCFAValue()) {
 383         plans_are_identical = eLazyBoolNo;
 384       }
 385       if (a_pc_regloc != b_pc_regloc) {
 386         plans_are_identical = eLazyBoolNo;
 387       }
 388     }
 389   }
 390   return plans_are_identical;
 391 }
 392
 393 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtNonCallSite(Target &target,
 394                                                        Thread &thread) {
 395   UnwindPlanSP eh_frame_sp = GetEHFrameUnwindPlan(target);
 396   if (!eh_frame_sp)
 397     eh_frame_sp = GetDebugFrameUnwindPlan(target);
 398   if (!eh_frame_sp)
 399     eh_frame_sp = GetObjectFileUnwindPlan(target);
 400   UnwindPlanSP arch_default_at_entry_sp =
 401       GetUnwindPlanArchitectureDefaultAtFunctionEntry(thread);
 402   UnwindPlanSP arch_default_sp = GetUnwindPlanArchitectureDefault(thread);
 403   UnwindPlanSP assembly_sp = GetAssemblyUnwindPlan(target, thread);
 404
 405   // This point of this code is to detect when a function is using a non-
 406   // standard ABI, and the eh_frame correctly describes that alternate ABI.
 407   // This is addressing a specific situation on x86_64 linux systems where one
 408   // function in a library pushes a value on the stack and jumps to another
 409   // function.  So using an assembly instruction based unwind will not work
 410   // when you're in the second function - the stack has been modified in a non-
 411   // ABI way.  But we have eh_frame that correctly describes how to unwind from
 412   // this location.  So we're looking to see if the initial pc register save
 413   // location from the eh_frame is different from the assembly unwind, the arch
 414   // default unwind, and the arch default at initial function entry.
 415   //
 416   // We may have eh_frame that describes the entire function -- or we may have
 417   // eh_frame that only describes the unwind after the prologue has executed --
 418   // so we need to check both the arch default (once the prologue has executed)
 419   // and the arch default at initial function entry.  And we may be running on
 420   // a target where we have only some of the assembly/arch default unwind plans
 421   // available.
 422
 423   if (CompareUnwindPlansForIdenticalInitialPCLocation(
 424           thread, eh_frame_sp, arch_default_at_entry_sp) == eLazyBoolNo &&
 425       CompareUnwindPlansForIdenticalInitialPCLocation(
 426           thread, eh_frame_sp, arch_default_sp) == eLazyBoolNo &&
 427       CompareUnwindPlansForIdenticalInitialPCLocation(
 428           thread, assembly_sp, arch_default_sp) == eLazyBoolNo) {
 429     return eh_frame_sp;
 430   }
 431
 432   if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))
 433     return plan_sp;
 434   if (UnwindPlanSP plan_sp = GetDebugFrameAugmentedUnwindPlan(target, thread))
 435     return plan_sp;
 436   if (UnwindPlanSP plan_sp = GetEHFrameAugmentedUnwindPlan(target, thread))
 437     return plan_sp;
 438   if (UnwindPlanSP plan_sp = GetObjectFileAugmentedUnwindPlan(target, thread))
 439     return plan_sp;
 440
 441   return assembly_sp;
 442 }
 443
 444 UnwindPlanSP FuncUnwinders::GetUnwindPlanFastUnwind(Target &target,
 445                                                     Thread &thread) {
 446   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 447   if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
 448     return m_unwind_plan_fast_sp;
 449
 450   m_tried_unwind_fast = true;
 451
 452   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 453   if (assembly_profiler_sp) {
 454     m_unwind_plan_fast_sp =
 455         std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 456     if (!assembly_profiler_sp->GetFastUnwindPlan(m_range, thread,
 457                                                  *m_unwind_plan_fast_sp)) {
 458       m_unwind_plan_fast_sp.reset();
 459     }
 460   }
 461   return m_unwind_plan_fast_sp;
 462 }
 463
 464 UnwindPlanSP FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) {
 465   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 466   if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
 467     return m_unwind_plan_arch_default_sp;
 468
 469   m_tried_unwind_arch_default = true;
 470
 471   Address current_pc;
 472   ProcessSP process_sp(thread.CalculateProcess());
 473   if (process_sp) {
 474     ABI *abi = process_sp->GetABI().get();
 475     if (abi) {
 476       m_unwind_plan_arch_default_sp =
 477           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 478       if (!abi->CreateDefaultUnwindPlan(*m_unwind_plan_arch_default_sp)) {
 479         m_unwind_plan_arch_default_sp.reset();
 480       }
 481     }
 482   }
 483
 484   return m_unwind_plan_arch_default_sp;
 485 }
 486
 487 UnwindPlanSP
 488 FuncUnwinders::GetUnwindPlanArchitectureDefaultAtFunctionEntry(Thread &thread) {
 489   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 490   if (m_unwind_plan_arch_default_at_func_entry_sp.get() ||
 491       m_tried_unwind_arch_default_at_func_entry)
 492     return m_unwind_plan_arch_default_at_func_entry_sp;
 493
 494   m_tried_unwind_arch_default_at_func_entry = true;
 495
 496   Address current_pc;
 497   ProcessSP process_sp(thread.CalculateProcess());
 498   if (process_sp) {
 499     ABI *abi = process_sp->GetABI().get();
 500     if (abi) {
 501       m_unwind_plan_arch_default_at_func_entry_sp =
 502           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
 503       if (!abi->CreateFunctionEntryUnwindPlan(
 504               *m_unwind_plan_arch_default_at_func_entry_sp)) {
 505         m_unwind_plan_arch_default_at_func_entry_sp.reset();
 506       }
 507     }
 508   }
 509
 510   return m_unwind_plan_arch_default_at_func_entry_sp;
 511 }
 512
 513 Address &FuncUnwinders::GetFirstNonPrologueInsn(Target &target) {
 514   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 515   if (m_first_non_prologue_insn.IsValid())
 516     return m_first_non_prologue_insn;
 517
 518   ExecutionContext exe_ctx(target.shared_from_this(), false);
 519   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
 520   if (assembly_profiler_sp)
 521     assembly_profiler_sp->FirstNonPrologueInsn(m_range, exe_ctx,
 522                                                m_first_non_prologue_insn);
 523   return m_first_non_prologue_insn;
 524 }
 525
 526 const Address &FuncUnwinders::GetFunctionStartAddress() const {
 527   return m_range.GetBaseAddress();
 528 }
 529
 530 lldb::UnwindAssemblySP
 531 FuncUnwinders::GetUnwindAssemblyProfiler(Target &target) {
 532   UnwindAssemblySP assembly_profiler_sp;
 533   if (ArchSpec arch = m_unwind_table.GetArchitecture()) {
 534     arch.MergeFrom(target.GetArchitecture());
 535     assembly_profiler_sp = UnwindAssembly::FindPlugin(arch);
 536   }
 537   return assembly_profiler_sp;
 538 }
 539
 540 Address FuncUnwinders::GetLSDAAddress(Target &target) {
 541   Address lsda_addr;
 542
 543   UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
 544   if (unwind_plan_sp.get() == nullptr) {
 545     unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
 546   }
 547   if (unwind_plan_sp.get() == nullptr) {
 548     unwind_plan_sp = GetObjectFileUnwindPlan(target);
 549   }
 550   if (unwind_plan_sp.get() && unwind_plan_sp->GetLSDAAddress().IsValid()) {
 551     lsda_addr = unwind_plan_sp->GetLSDAAddress();
 552   }
 553   return lsda_addr;
 554 }
 555
 556 Address FuncUnwinders::GetPersonalityRoutinePtrAddress(Target &target) {
 557   Address personality_addr;
 558
 559   UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
 560   if (unwind_plan_sp.get() == nullptr) {
 561     unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
 562   }
 563   if (unwind_plan_sp.get() == nullptr) {
 564     unwind_plan_sp = GetObjectFileUnwindPlan(target);
 565   }
 566   if (unwind_plan_sp.get() &&
 567       unwind_plan_sp->GetPersonalityFunctionPtr().IsValid()) {
 568     personality_addr = unwind_plan_sp->GetPersonalityFunctionPtr();
 569   }
 570
 571   return personality_addr;
 572 }