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/lldb-private.h" 11 #include "lldb/Symbol/FuncUnwinders.h" 12 #include "lldb/Symbol/ObjectFile.h" 13 #include "lldb/Symbol/UnwindPlan.h" 14 #include "lldb/Core/AddressRange.h" 15 #include "lldb/Core/Address.h" 16 #include "lldb/Symbol/UnwindTable.h" 17 #include "lldb/Utility/UnwindAssemblyProfiler.h" 18 #include "lldb/Utility/ArchDefaultUnwindPlan.h" 19 #include "lldb/Symbol/DWARFCallFrameInfo.h" 20 #include "lldb/Target/Thread.h" 21 #include "lldb/Target/Target.h" 22 23 using namespace lldb; 24 using namespace lldb_private; 25 26 27 FuncUnwinders::FuncUnwinders 28 ( 29 UnwindTable& unwind_table, 30 UnwindAssemblyProfiler *assembly_profiler, 31 AddressRange range 32 ) : 33 m_unwind_table(unwind_table), 34 m_assembly_profiler(assembly_profiler), 35 m_range(range), 36 m_mutex (Mutex::eMutexTypeNormal), 37 m_unwind_plan_call_site_sp (), 38 m_unwind_plan_non_call_site_sp (), 39 m_unwind_plan_fast_sp (), 40 m_unwind_plan_arch_default_sp (), 41 m_tried_unwind_at_call_site (false), 42 m_tried_unwind_at_non_call_site (false), 43 m_tried_unwind_fast (false), 44 m_tried_unwind_arch_default (false), 45 m_first_non_prologue_insn() 46 { 47 } 48 49 FuncUnwinders::~FuncUnwinders () 50 { 51 } 52 53 UnwindPlanSP 54 FuncUnwinders::GetUnwindPlanAtCallSite (int current_offset) 55 { 56 // Lock the mutex to ensure we can always give out the most appropriate 57 // information. We want to make sure if someone requests a call site unwind 58 // plan, that they get one and don't run into a race condition where one 59 // thread has started to create the unwind plan and has put it into 60 // m_unwind_plan_call_site_sp, and have another thread enter this function 61 // and return the partially filled in m_unwind_plan_call_site_sp pointer. 62 // We also want to make sure that we lock out other unwind plans from 63 // being accessed until this one is done creating itself in case someone 64 // had some code like: 65 // UnwindPlan *best_unwind_plan = ...GetUnwindPlanAtCallSite (...) 66 // if (best_unwind_plan == NULL) 67 // best_unwind_plan = GetUnwindPlanAtNonCallSite (...) 68 Mutex::Locker locker (m_mutex); 69 if (m_tried_unwind_at_call_site == false && m_unwind_plan_call_site_sp.get() == NULL) 70 { 71 m_tried_unwind_at_call_site = true; 72 // We have cases (e.g. with _sigtramp on Mac OS X) where the hand-written eh_frame unwind info for a 73 // function does not cover the entire range of the function and so the FDE only lists a subset of the 74 // address range. If we try to look up the unwind info by the starting address of the function 75 // (i.e. m_range.GetBaseAddress()) we may not find the eh_frame FDE. We need to use the actual byte offset 76 // into the function when looking it up. 77 78 if (m_range.GetBaseAddress().IsValid()) 79 { 80 Address current_pc (m_range.GetBaseAddress ()); 81 if (current_offset != -1) 82 current_pc.SetOffset (current_pc.GetOffset() + current_offset); 83 84 DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo(); 85 if (eh_frame) 86 { 87 m_unwind_plan_call_site_sp.reset (new UnwindPlan); 88 if (!eh_frame->GetUnwindPlan (current_pc, *m_unwind_plan_call_site_sp)) 89 m_unwind_plan_call_site_sp.reset(); 90 } 91 } 92 } 93 return m_unwind_plan_call_site_sp; 94 } 95 96 UnwindPlanSP 97 FuncUnwinders::GetUnwindPlanAtNonCallSite (Thread& thread) 98 { 99 // Lock the mutex to ensure we can always give out the most appropriate 100 // information. We want to make sure if someone requests an unwind 101 // plan, that they get one and don't run into a race condition where one 102 // thread has started to create the unwind plan and has put it into 103 // the auto_ptr member variable, and have another thread enter this function 104 // and return the partially filled pointer contained in the auto_ptr. 105 // We also want to make sure that we lock out other unwind plans from 106 // being accessed until this one is done creating itself in case someone 107 // had some code like: 108 // UnwindPlan *best_unwind_plan = ...GetUnwindPlanAtCallSite (...) 109 // if (best_unwind_plan == NULL) 110 // best_unwind_plan = GetUnwindPlanAtNonCallSite (...) 111 Mutex::Locker locker (m_mutex); 112 if (m_tried_unwind_at_non_call_site == false && m_unwind_plan_non_call_site_sp.get() == NULL) 113 { 114 m_tried_unwind_at_non_call_site = true; 115 m_unwind_plan_non_call_site_sp.reset (new UnwindPlan); 116 if (!m_assembly_profiler->GetNonCallSiteUnwindPlanFromAssembly (m_range, thread, *m_unwind_plan_non_call_site_sp)) 117 m_unwind_plan_non_call_site_sp.reset(); 118 } 119 return m_unwind_plan_non_call_site_sp; 120 } 121 122 UnwindPlanSP 123 FuncUnwinders::GetUnwindPlanFastUnwind (Thread& thread) 124 { 125 // Lock the mutex to ensure we can always give out the most appropriate 126 // information. We want to make sure if someone requests an unwind 127 // plan, that they get one and don't run into a race condition where one 128 // thread has started to create the unwind plan and has put it into 129 // the auto_ptr member variable, and have another thread enter this function 130 // and return the partially filled pointer contained in the auto_ptr. 131 // We also want to make sure that we lock out other unwind plans from 132 // being accessed until this one is done creating itself in case someone 133 // had some code like: 134 // UnwindPlan *best_unwind_plan = ...GetUnwindPlanAtCallSite (...) 135 // if (best_unwind_plan == NULL) 136 // best_unwind_plan = GetUnwindPlanAtNonCallSite (...) 137 Mutex::Locker locker (m_mutex); 138 if (m_tried_unwind_fast == false && m_unwind_plan_fast_sp.get() == NULL) 139 { 140 m_tried_unwind_fast = true; 141 m_unwind_plan_fast_sp.reset (new UnwindPlan); 142 if (!m_assembly_profiler->GetFastUnwindPlan (m_range, thread, *m_unwind_plan_fast_sp)) 143 m_unwind_plan_fast_sp.reset(); 144 } 145 return m_unwind_plan_fast_sp; 146 } 147 148 UnwindPlanSP 149 FuncUnwinders::GetUnwindPlanArchitectureDefault (Thread& thread) 150 { 151 // Lock the mutex to ensure we can always give out the most appropriate 152 // information. We want to make sure if someone requests an unwind 153 // plan, that they get one and don't run into a race condition where one 154 // thread has started to create the unwind plan and has put it into 155 // the auto_ptr member variable, and have another thread enter this function 156 // and return the partially filled pointer contained in the auto_ptr. 157 // We also want to make sure that we lock out other unwind plans from 158 // being accessed until this one is done creating itself in case someone 159 // had some code like: 160 // UnwindPlan *best_unwind_plan = ...GetUnwindPlanAtCallSite (...) 161 // if (best_unwind_plan == NULL) 162 // best_unwind_plan = GetUnwindPlanAtNonCallSite (...) 163 Mutex::Locker locker (m_mutex); 164 if (m_tried_unwind_arch_default == false && m_unwind_plan_arch_default_sp.get() == NULL) 165 { 166 m_tried_unwind_arch_default = true; 167 Address current_pc; 168 Target *target = thread.CalculateTarget(); 169 if (target) 170 { 171 ArchDefaultUnwindPlanSP arch_default_sp (ArchDefaultUnwindPlan::FindPlugin (target->GetArchitecture ())); 172 if (arch_default_sp) 173 m_unwind_plan_arch_default_sp = arch_default_sp->GetArchDefaultUnwindPlan (thread, current_pc); 174 } 175 } 176 177 return m_unwind_plan_arch_default_sp; 178 } 179 180 Address& 181 FuncUnwinders::GetFirstNonPrologueInsn (Target& target) 182 { 183 if (m_first_non_prologue_insn.IsValid()) 184 return m_first_non_prologue_insn; 185 m_assembly_profiler->FirstNonPrologueInsn (m_range, target, NULL, m_first_non_prologue_insn); 186 return m_first_non_prologue_insn; 187 } 188 189 const Address& 190 FuncUnwinders::GetFunctionStartAddress () const 191 { 192 return m_range.GetBaseAddress(); 193 } 194 195