source/Symbol/FuncUnwinders.cpp

   1 //===-- FuncUnwinders.cpp ----------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/AddressRange.h"
  11 #include "lldb/Core/Address.h"
  12 #include "lldb/Symbol/FuncUnwinders.h"
  13 #include "lldb/Symbol/ArmUnwindInfo.h"
  14 #include "lldb/Symbol/DWARFCallFrameInfo.h"
  15 #include "lldb/Symbol/CompactUnwindInfo.h"
  16 #include "lldb/Symbol/ObjectFile.h"
  17 #include "lldb/Symbol/UnwindPlan.h"
  18 #include "lldb/Symbol/UnwindTable.h"
  19 #include "lldb/Target/ABI.h"
  20 #include "lldb/Target/ExecutionContext.h"
  21 #include "lldb/Target/Process.h"
  22 #include "lldb/Target/Thread.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/UnwindAssembly.h"
  25 #include "lldb/Utility/RegisterNumber.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 //------------------------------------------------
  31 /// constructor
  32 //------------------------------------------------
  33
  34 FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
  35     : m_unwind_table(unwind_table),
  36       m_range(range),
  37       m_mutex(),
  38       m_unwind_plan_assembly_sp(),
  39       m_unwind_plan_eh_frame_sp(),
  40       m_unwind_plan_eh_frame_augmented_sp(),
  41       m_unwind_plan_compact_unwind(),
  42       m_unwind_plan_arm_unwind_sp(),
  43       m_unwind_plan_fast_sp(),
  44       m_unwind_plan_arch_default_sp(),
  45       m_unwind_plan_arch_default_at_func_entry_sp(),
  46       m_tried_unwind_plan_assembly(false),
  47       m_tried_unwind_plan_eh_frame(false),
  48       m_tried_unwind_plan_eh_frame_augmented(false),
  49       m_tried_unwind_plan_compact_unwind(false),
  50       m_tried_unwind_plan_arm_unwind(false),
  51       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 }
  57
  58 //------------------------------------------------
  59 /// destructor
  60 //------------------------------------------------
  61
  62 FuncUnwinders::~FuncUnwinders ()
  63 {
  64 }
  65
  66 UnwindPlanSP
  67 FuncUnwinders::GetUnwindPlanAtCallSite (Target &target, int current_offset)
  68 {
  69     std::lock_guard<std::recursive_mutex> guard(m_mutex);
  70
  71     UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan (target, current_offset);
  72     if (unwind_plan_sp)
  73         return unwind_plan_sp;
  74
  75     unwind_plan_sp = GetCompactUnwindUnwindPlan (target, current_offset);
  76     if (unwind_plan_sp)
  77         return unwind_plan_sp;
  78
  79     unwind_plan_sp = GetArmUnwindUnwindPlan (target, current_offset);
  80     if (unwind_plan_sp)
  81         return unwind_plan_sp;
  82
  83     return nullptr;
  84 }
  85
  86 UnwindPlanSP
  87 FuncUnwinders::GetCompactUnwindUnwindPlan (Target &target, int current_offset)
  88 {
  89     if (m_unwind_plan_compact_unwind.size() > 0)
  90         return m_unwind_plan_compact_unwind[0];    // FIXME support multiple compact unwind plans for one func
  91     if (m_tried_unwind_plan_compact_unwind)
  92         return UnwindPlanSP();
  93
  94     std::lock_guard<std::recursive_mutex> guard(m_mutex);
  95     m_tried_unwind_plan_compact_unwind = true;
  96     if (m_range.GetBaseAddress().IsValid())
  97     {
  98         Address current_pc (m_range.GetBaseAddress ());
  99         if (current_offset != -1)
 100             current_pc.SetOffset (current_pc.GetOffset() + current_offset);
 101         CompactUnwindInfo *compact_unwind = m_unwind_table.GetCompactUnwindInfo();
 102         if (compact_unwind)
 103         {
 104             UnwindPlanSP unwind_plan_sp (new UnwindPlan (lldb::eRegisterKindGeneric));
 105             if (compact_unwind->GetUnwindPlan (target, current_pc, *unwind_plan_sp))
 106             {
 107                 m_unwind_plan_compact_unwind.push_back (unwind_plan_sp);
 108                 return m_unwind_plan_compact_unwind[0];    // FIXME support multiple compact unwind plans for one func
 109             }
 110         }
 111     }
 112     return UnwindPlanSP();
 113 }
 114
 115 UnwindPlanSP
 116 FuncUnwinders::GetEHFrameUnwindPlan (Target &target, int current_offset)
 117 {
 118     if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
 119         return m_unwind_plan_eh_frame_sp;
 120
 121     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 122     m_tried_unwind_plan_eh_frame = true;
 123     if (m_range.GetBaseAddress().IsValid())
 124     {
 125         Address current_pc (m_range.GetBaseAddress ());
 126         if (current_offset != -1)
 127             current_pc.SetOffset (current_pc.GetOffset() + current_offset);
 128         DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
 129         if (eh_frame)
 130         {
 131             m_unwind_plan_eh_frame_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 132             if (!eh_frame->GetUnwindPlan (current_pc, *m_unwind_plan_eh_frame_sp))
 133                 m_unwind_plan_eh_frame_sp.reset();
 134         }
 135     }
 136     return m_unwind_plan_eh_frame_sp;
 137 }
 138
 139 UnwindPlanSP
 140 FuncUnwinders::GetArmUnwindUnwindPlan (Target &target, int current_offset)
 141 {
 142     if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
 143         return m_unwind_plan_arm_unwind_sp;
 144
 145     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 146     m_tried_unwind_plan_arm_unwind = true;
 147     if (m_range.GetBaseAddress().IsValid())
 148     {
 149         Address current_pc (m_range.GetBaseAddress ());
 150         if (current_offset != -1)
 151             current_pc.SetOffset (current_pc.GetOffset() + current_offset);
 152         ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
 153         if (arm_unwind_info)
 154         {
 155             m_unwind_plan_arm_unwind_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 156             if (!arm_unwind_info->GetUnwindPlan (target, current_pc, *m_unwind_plan_arm_unwind_sp))
 157                 m_unwind_plan_arm_unwind_sp.reset();
 158         }
 159     }
 160     return m_unwind_plan_arm_unwind_sp;
 161 }
 162
 163 UnwindPlanSP
 164 FuncUnwinders::GetEHFrameAugmentedUnwindPlan (Target &target, Thread &thread, int current_offset)
 165 {
 166     if (m_unwind_plan_eh_frame_augmented_sp.get() || m_tried_unwind_plan_eh_frame_augmented)
 167         return m_unwind_plan_eh_frame_augmented_sp;
 168
 169     // Only supported on x86 architectures where we get eh_frame from the compiler that describes
 170     // the prologue instructions perfectly, and sometimes the epilogue instructions too.
 171     if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386
 172         && target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64
 173         && target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h)
 174     {
 175             m_tried_unwind_plan_eh_frame_augmented = true;
 176             return m_unwind_plan_eh_frame_augmented_sp;
 177     }
 178
 179     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 180     m_tried_unwind_plan_eh_frame_augmented = true;
 181
 182     UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan (target, current_offset);
 183     if (!eh_frame_plan)
 184         return m_unwind_plan_eh_frame_augmented_sp;
 185
 186     m_unwind_plan_eh_frame_augmented_sp.reset(new UnwindPlan(*eh_frame_plan));
 187
 188     // Augment the eh_frame instructions with epilogue descriptions if necessary so the
 189     // UnwindPlan can be used at any instruction in the function.
 190
 191     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));
 192     if (assembly_profiler_sp)
 193     {
 194         if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite (m_range, thread, *m_unwind_plan_eh_frame_augmented_sp))
 195         {
 196             m_unwind_plan_eh_frame_augmented_sp.reset();
 197         }
 198     }
 199     else
 200     {
 201         m_unwind_plan_eh_frame_augmented_sp.reset();
 202     }
 203     return m_unwind_plan_eh_frame_augmented_sp;
 204 }
 205
 206
 207 UnwindPlanSP
 208 FuncUnwinders::GetAssemblyUnwindPlan (Target &target, Thread &thread, int current_offset)
 209 {
 210     if (m_unwind_plan_assembly_sp.get()
 211         || m_tried_unwind_plan_assembly
 212         || m_unwind_table.GetAllowAssemblyEmulationUnwindPlans () == false)
 213     {
 214         return m_unwind_plan_assembly_sp;
 215     }
 216
 217     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 218     m_tried_unwind_plan_assembly = true;
 219
 220     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));
 221     if (assembly_profiler_sp)
 222     {
 223         m_unwind_plan_assembly_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 224         if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly (m_range, thread, *m_unwind_plan_assembly_sp))
 225         {
 226             m_unwind_plan_assembly_sp.reset();
 227         }
 228     }
 229     return m_unwind_plan_assembly_sp;
 230 }
 231
 232 // This method compares the pc unwind rule in the first row of two UnwindPlans.
 233 // If they have the same way of getting the pc value (e.g. "CFA - 8" + "CFA is sp"),
 234 // then it will return LazyBoolTrue.
 235 LazyBool
 236 FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation (Thread& thread, const UnwindPlanSP &a, const UnwindPlanSP &b)
 237 {
 238     LazyBool plans_are_identical = eLazyBoolCalculate;
 239
 240     RegisterNumber pc_reg (thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 241     uint32_t pc_reg_lldb_regnum = pc_reg.GetAsKind (eRegisterKindLLDB);
 242
 243     if (a.get() && b.get())
 244     {
 245         UnwindPlan::RowSP a_first_row = a->GetRowAtIndex (0);
 246         UnwindPlan::RowSP b_first_row = b->GetRowAtIndex (0);
 247
 248         if (a_first_row.get() && b_first_row.get())
 249         {
 250             UnwindPlan::Row::RegisterLocation a_pc_regloc;
 251             UnwindPlan::Row::RegisterLocation b_pc_regloc;
 252
 253             a_first_row->GetRegisterInfo (pc_reg_lldb_regnum, a_pc_regloc);
 254             b_first_row->GetRegisterInfo (pc_reg_lldb_regnum, b_pc_regloc);
 255
 256             plans_are_identical = eLazyBoolYes;
 257
 258             if (a_first_row->GetCFAValue() != b_first_row->GetCFAValue())
 259             {
 260                 plans_are_identical = eLazyBoolNo;
 261             }
 262             if (a_pc_regloc != b_pc_regloc)
 263             {
 264                 plans_are_identical = eLazyBoolNo;
 265             }
 266         }
 267     }
 268     return plans_are_identical;
 269 }
 270
 271 UnwindPlanSP
 272 FuncUnwinders::GetUnwindPlanAtNonCallSite (Target& target, Thread& thread, int current_offset)
 273 {
 274     UnwindPlanSP eh_frame_sp = GetEHFrameUnwindPlan (target, current_offset);
 275     UnwindPlanSP arch_default_at_entry_sp = GetUnwindPlanArchitectureDefaultAtFunctionEntry (thread);
 276     UnwindPlanSP arch_default_sp = GetUnwindPlanArchitectureDefault (thread);
 277     UnwindPlanSP assembly_sp = GetAssemblyUnwindPlan (target, thread, current_offset);
 278
 279     // This point of this code is to detect when a function is using a non-standard ABI, and the eh_frame
 280     // correctly describes that alternate ABI.  This is addressing a specific situation on x86_64 linux
 281     // systems where one function in a library pushes a value on the stack and jumps to another function.
 282     // So using an assembly instruction based unwind will not work when you're in the second function -
 283     // the stack has been modified in a non-ABI way.  But we have eh_frame that correctly describes how to
 284     // unwind from this location.  So we're looking to see if the initial pc register save location from
 285     // the eh_frame is different from the assembly unwind, the arch default unwind, and the arch default at
 286     // initial function entry.
 287     //
 288     // We may have eh_frame that describes the entire function -- or we may have eh_frame that only describes
 289     // the unwind after the prologue has executed -- so we need to check both the arch default (once the prologue
 290     // has executed) and the arch default at initial function entry.  And we may be running on a target where
 291     // we have only some of the assembly/arch default unwind plans available.
 292
 293     if (CompareUnwindPlansForIdenticalInitialPCLocation (thread, eh_frame_sp, arch_default_at_entry_sp) == eLazyBoolNo
 294         && CompareUnwindPlansForIdenticalInitialPCLocation (thread, eh_frame_sp, arch_default_sp) == eLazyBoolNo
 295         && CompareUnwindPlansForIdenticalInitialPCLocation (thread, assembly_sp, arch_default_sp) == eLazyBoolNo)
 296     {
 297         return eh_frame_sp;
 298     }
 299
 300     UnwindPlanSP eh_frame_augmented_sp = GetEHFrameAugmentedUnwindPlan (target, thread, current_offset);
 301     if (eh_frame_augmented_sp)
 302     {
 303         return eh_frame_augmented_sp;
 304     }
 305
 306     return assembly_sp;
 307 }
 308
 309 UnwindPlanSP
 310 FuncUnwinders::GetUnwindPlanFastUnwind (Target& target, Thread& thread)
 311 {
 312     if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
 313         return m_unwind_plan_fast_sp;
 314
 315     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 316     m_tried_unwind_fast = true;
 317
 318     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));
 319     if (assembly_profiler_sp)
 320     {
 321         m_unwind_plan_fast_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 322         if (!assembly_profiler_sp->GetFastUnwindPlan (m_range, thread, *m_unwind_plan_fast_sp))
 323         {
 324             m_unwind_plan_fast_sp.reset();
 325         }
 326     }
 327     return m_unwind_plan_fast_sp;
 328 }
 329
 330 UnwindPlanSP
 331 FuncUnwinders::GetUnwindPlanArchitectureDefault (Thread& thread)
 332 {
 333     if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
 334         return m_unwind_plan_arch_default_sp;
 335
 336     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 337     m_tried_unwind_arch_default = true;
 338
 339     Address current_pc;
 340     ProcessSP process_sp (thread.CalculateProcess());
 341     if (process_sp)
 342     {
 343         ABI *abi = process_sp->GetABI().get();
 344         if (abi)
 345         {
 346             m_unwind_plan_arch_default_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 347             if (!abi->CreateDefaultUnwindPlan(*m_unwind_plan_arch_default_sp))
 348             {
 349                 m_unwind_plan_arch_default_sp.reset();
 350             }
 351         }
 352     }
 353
 354     return m_unwind_plan_arch_default_sp;
 355 }
 356
 357 UnwindPlanSP
 358 FuncUnwinders::GetUnwindPlanArchitectureDefaultAtFunctionEntry (Thread& thread)
 359 {
 360     if (m_unwind_plan_arch_default_at_func_entry_sp.get() || m_tried_unwind_arch_default_at_func_entry)
 361         return m_unwind_plan_arch_default_at_func_entry_sp;
 362
 363     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 364     m_tried_unwind_arch_default_at_func_entry = true;
 365
 366     Address current_pc;
 367     ProcessSP process_sp (thread.CalculateProcess());
 368     if (process_sp)
 369     {
 370         ABI *abi = process_sp->GetABI().get();
 371         if (abi)
 372         {
 373             m_unwind_plan_arch_default_at_func_entry_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 374             if (!abi->CreateFunctionEntryUnwindPlan(*m_unwind_plan_arch_default_at_func_entry_sp))
 375             {
 376                 m_unwind_plan_arch_default_at_func_entry_sp.reset();
 377             }
 378         }
 379     }
 380
 381     return m_unwind_plan_arch_default_at_func_entry_sp;
 382 }
 383
 384
 385 Address&
 386 FuncUnwinders::GetFirstNonPrologueInsn (Target& target)
 387 {
 388     if (m_first_non_prologue_insn.IsValid())
 389         return m_first_non_prologue_insn;
 390
 391     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 392     ExecutionContext exe_ctx (target.shared_from_this(), false);
 393     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));
 394     if (assembly_profiler_sp)
 395         assembly_profiler_sp->FirstNonPrologueInsn (m_range, exe_ctx, m_first_non_prologue_insn);
 396     return m_first_non_prologue_insn;
 397 }
 398
 399 const Address&
 400 FuncUnwinders::GetFunctionStartAddress () const
 401 {
 402     return m_range.GetBaseAddress();
 403 }
 404
 405 lldb::UnwindAssemblySP
 406 FuncUnwinders::GetUnwindAssemblyProfiler (Target& target)
 407 {
 408     UnwindAssemblySP assembly_profiler_sp;
 409     ArchSpec arch;
 410     if (m_unwind_table.GetArchitecture (arch))
 411     {
 412         arch.MergeFrom (target.GetArchitecture ());
 413         assembly_profiler_sp = UnwindAssembly::FindPlugin (arch);
 414     }
 415     return assembly_profiler_sp;
 416 }
 417
 418 Address
 419 FuncUnwinders::GetLSDAAddress (Target &target)
 420 {
 421     Address lsda_addr;
 422
 423     UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan (target, -1);
 424     if (unwind_plan_sp.get() == nullptr)
 425     {
 426         unwind_plan_sp = GetCompactUnwindUnwindPlan (target, -1);
 427     }
 428     if (unwind_plan_sp.get() && unwind_plan_sp->GetLSDAAddress().IsValid())
 429     {
 430         lsda_addr = unwind_plan_sp->GetLSDAAddress();
 431     }
 432     return lsda_addr;
 433 }
 434
 435
 436 Address
 437 FuncUnwinders::GetPersonalityRoutinePtrAddress (Target &target)
 438 {
 439     Address personality_addr;
 440
 441     UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan (target, -1);
 442     if (unwind_plan_sp.get() == nullptr)
 443     {
 444         unwind_plan_sp = GetCompactUnwindUnwindPlan (target, -1);
 445     }
 446     if (unwind_plan_sp.get() && unwind_plan_sp->GetPersonalityFunctionPtr().IsValid())
 447     {
 448         personality_addr = unwind_plan_sp->GetPersonalityFunctionPtr();
 449     }
 450
 451     return personality_addr;
 452 }