1 //===-- UnwindLLDB.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/Module.h" 11 #include "lldb/Core/Log.h" 12 #include "lldb/Symbol/FuncUnwinders.h" 13 #include "lldb/Symbol/Function.h" 14 #include "lldb/Symbol/UnwindPlan.h" 15 #include "lldb/Target/Thread.h" 16 #include "lldb/Target/Target.h" 17 #include "lldb/Target/Process.h" 18 #include "lldb/Target/RegisterContext.h" 19 20 #include "UnwindLLDB.h" 21 #include "RegisterContextLLDB.h" 22 23 using namespace lldb; 24 using namespace lldb_private; 25 26 UnwindLLDB::UnwindLLDB (Thread &thread) : 27 Unwind (thread), 28 m_frames(), 29 m_unwind_complete(false) 30 { 31 } 32 33 uint32_t 34 UnwindLLDB::DoGetFrameCount() 35 { 36 if (!m_unwind_complete) 37 { 38 //#define DEBUG_FRAME_SPEED 1 39 #if DEBUG_FRAME_SPEED 40 #define FRAME_COUNT 10000 41 TimeValue time_value (TimeValue::Now()); 42 #endif 43 if (!AddFirstFrame ()) 44 return 0; 45 46 ProcessSP process_sp (m_thread.GetProcess()); 47 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 48 49 while (AddOneMoreFrame (abi)) 50 { 51 #if DEBUG_FRAME_SPEED 52 if ((m_frames.size() % FRAME_COUNT) == 0) 53 { 54 TimeValue now(TimeValue::Now()); 55 uint64_t delta_t = now - time_value; 56 printf ("%u frames in %" PRIu64 ".%09llu ms (%g frames/sec)\n", 57 FRAME_COUNT, 58 delta_t / TimeValue::NanoSecPerSec, 59 delta_t % TimeValue::NanoSecPerSec, 60 (float)FRAME_COUNT / ((float)delta_t / (float)TimeValue::NanoSecPerSec)); 61 time_value = now; 62 } 63 #endif 64 } 65 } 66 return m_frames.size (); 67 } 68 69 bool 70 UnwindLLDB::AddFirstFrame () 71 { 72 if (m_frames.size() > 0) 73 return true; 74 75 // First, set up the 0th (initial) frame 76 CursorSP first_cursor_sp(new Cursor ()); 77 RegisterContextLLDBSP reg_ctx_sp (new RegisterContextLLDB (m_thread, 78 RegisterContextLLDBSP(), 79 first_cursor_sp->sctx, 80 0, *this)); 81 if (reg_ctx_sp.get() == NULL) 82 goto unwind_done; 83 84 if (!reg_ctx_sp->IsValid()) 85 goto unwind_done; 86 87 if (!reg_ctx_sp->GetCFA (first_cursor_sp->cfa)) 88 goto unwind_done; 89 90 if (!reg_ctx_sp->ReadPC (first_cursor_sp->start_pc)) 91 goto unwind_done; 92 93 // Everything checks out, so release the auto pointer value and let the 94 // cursor own it in its shared pointer 95 first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 96 m_frames.push_back (first_cursor_sp); 97 return true; 98 unwind_done: 99 m_unwind_complete = true; 100 return false; 101 } 102 103 // For adding a non-zero stack frame to m_frames. 104 bool 105 UnwindLLDB::AddOneMoreFrame (ABI *abi) 106 { 107 // If we've already gotten to the end of the stack, don't bother to try again... 108 if (m_unwind_complete) 109 return false; 110 111 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND)); 112 CursorSP cursor_sp(new Cursor ()); 113 114 // Frame zero is a little different 115 if (m_frames.size() == 0) 116 return false; 117 118 uint32_t cur_idx = m_frames.size (); 119 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB (m_thread, 120 m_frames[cur_idx - 1]->reg_ctx_lldb_sp, 121 cursor_sp->sctx, 122 cur_idx, 123 *this)); 124 125 // We want to detect an unwind that cycles erronously and stop backtracing. 126 // Don't want this maximum unwind limit to be too low -- if you have a backtrace 127 // with an "infinitely recursing" bug, it will crash when the stack blows out 128 // and the first 35,000 frames are uninteresting - it's the top most 5 frames that 129 // you actually care about. So you can't just cap the unwind at 10,000 or something. 130 // Realistically anything over around 200,000 is going to blow out the stack space. 131 // If we're still unwinding at that point, we're probably never going to finish. 132 if (cur_idx > 300000) 133 { 134 if (log) 135 log->Printf ("%*sFrame %d unwound too many frames, assuming unwind has gone astray, stopping.", 136 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 137 goto unwind_done; 138 } 139 140 if (reg_ctx_sp.get() == NULL) 141 goto unwind_done; 142 143 if (!reg_ctx_sp->IsValid()) 144 { 145 if (log) 146 { 147 log->Printf("%*sFrame %d invalid RegisterContext for this frame, stopping stack walk", 148 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 149 } 150 goto unwind_done; 151 } 152 if (!reg_ctx_sp->GetCFA (cursor_sp->cfa)) 153 { 154 if (log) 155 { 156 log->Printf("%*sFrame %d did not get CFA for this frame, stopping stack walk", 157 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 158 } 159 goto unwind_done; 160 } 161 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) 162 { 163 if (log) 164 { 165 log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk", 166 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 167 } 168 goto unwind_done; 169 } 170 if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc)) 171 { 172 if (log) 173 { 174 log->Printf("%*sFrame %d did not get PC for this frame, stopping stack walk", 175 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 176 } 177 goto unwind_done; 178 } 179 if (abi && !abi->CodeAddressIsValid (cursor_sp->start_pc)) 180 { 181 if (log) 182 { 183 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk", 184 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 185 } 186 goto unwind_done; 187 } 188 if (!m_frames.empty()) 189 { 190 if (m_frames.back()->start_pc == cursor_sp->start_pc) 191 { 192 if (m_frames.back()->cfa == cursor_sp->cfa) 193 goto unwind_done; // Infinite loop where the current cursor is the same as the previous one... 194 else if (abi && abi->StackUsesFrames()) 195 { 196 // We might have a CFA that is not using the frame pointer and 197 // we want to validate that the frame pointer is valid. 198 if (reg_ctx_sp->GetFP() == 0) 199 goto unwind_done; 200 } 201 } 202 } 203 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 204 m_frames.push_back (cursor_sp); 205 return true; 206 207 unwind_done: 208 m_unwind_complete = true; 209 return false; 210 } 211 212 bool 213 UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc) 214 { 215 if (m_frames.size() == 0) 216 { 217 if (!AddFirstFrame()) 218 return false; 219 } 220 221 ProcessSP process_sp (m_thread.GetProcess()); 222 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 223 224 while (idx >= m_frames.size() && AddOneMoreFrame (abi)) 225 ; 226 227 if (idx < m_frames.size ()) 228 { 229 cfa = m_frames[idx]->cfa; 230 pc = m_frames[idx]->start_pc; 231 return true; 232 } 233 return false; 234 } 235 236 lldb::RegisterContextSP 237 UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame) 238 { 239 lldb::RegisterContextSP reg_ctx_sp; 240 uint32_t idx = frame->GetConcreteFrameIndex (); 241 242 if (idx == 0) 243 { 244 return m_thread.GetRegisterContext(); 245 } 246 247 if (m_frames.size() == 0) 248 { 249 if (!AddFirstFrame()) 250 return reg_ctx_sp; 251 } 252 253 ProcessSP process_sp (m_thread.GetProcess()); 254 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 255 256 while (idx >= m_frames.size()) 257 { 258 if (!AddOneMoreFrame (abi)) 259 break; 260 } 261 262 const uint32_t num_frames = m_frames.size(); 263 if (idx < num_frames) 264 { 265 Cursor *frame_cursor = m_frames[idx].get(); 266 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp; 267 } 268 return reg_ctx_sp; 269 } 270 271 UnwindLLDB::RegisterContextLLDBSP 272 UnwindLLDB::GetRegisterContextForFrameNum (uint32_t frame_num) 273 { 274 RegisterContextLLDBSP reg_ctx_sp; 275 if (frame_num < m_frames.size()) 276 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp; 277 return reg_ctx_sp; 278 } 279 280 bool 281 UnwindLLDB::SearchForSavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc, uint32_t starting_frame_num, bool pc_reg) 282 { 283 int64_t frame_num = starting_frame_num; 284 if (frame_num >= m_frames.size()) 285 return false; 286 287 // Never interrogate more than one level while looking for the saved pc value. If the value 288 // isn't saved by frame_num, none of the frames lower on the stack will have a useful value. 289 if (pc_reg) 290 { 291 UnwindLLDB::RegisterSearchResult result; 292 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc); 293 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 294 return true; 295 else 296 return false; 297 } 298 while (frame_num >= 0) 299 { 300 UnwindLLDB::RegisterSearchResult result; 301 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc); 302 303 // If we have unwind instructions saying that register N is saved in register M in the middle of 304 // the stack (and N can equal M here, meaning the register was not used in this function), then 305 // change the register number we're looking for to M and keep looking for a concrete location 306 // down the stack, or an actual value from a live RegisterContext at frame 0. 307 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound 308 && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister 309 && frame_num > 0) 310 { 311 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 312 lldb_regnum = regloc.location.register_number; 313 } 314 315 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 316 return true; 317 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile) 318 return false; 319 frame_num--; 320 } 321 return false; 322 } 323
