contrib/llvm-project/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp

   1 //===-- UnwindLLDB.cpp -------------------------------------*- C++ -*-===//
   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/Core/Module.h"
  10 #include "lldb/Symbol/FuncUnwinders.h"
  11 #include "lldb/Symbol/Function.h"
  12 #include "lldb/Symbol/UnwindPlan.h"
  13 #include "lldb/Target/ABI.h"
  14 #include "lldb/Target/Process.h"
  15 #include "lldb/Target/RegisterContext.h"
  16 #include "lldb/Target/Target.h"
  17 #include "lldb/Target/Thread.h"
  18 #include "lldb/Utility/Log.h"
  19
  20 #include "RegisterContextLLDB.h"
  21 #include "UnwindLLDB.h"
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 UnwindLLDB::UnwindLLDB(Thread &thread)
  27     : Unwind(thread), m_frames(), m_unwind_complete(false),
  28       m_user_supplied_trap_handler_functions() {
  29   ProcessSP process_sp(thread.GetProcess());
  30   if (process_sp) {
  31     Args args;
  32     process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames(args);
  33     size_t count = args.GetArgumentCount();
  34     for (size_t i = 0; i < count; i++) {
  35       const char *func_name = args.GetArgumentAtIndex(i);
  36       m_user_supplied_trap_handler_functions.push_back(ConstString(func_name));
  37     }
  38   }
  39 }
  40
  41 uint32_t UnwindLLDB::DoGetFrameCount() {
  42   if (!m_unwind_complete) {
  43 //#define DEBUG_FRAME_SPEED 1
  44 #if DEBUG_FRAME_SPEED
  45 #define FRAME_COUNT 10000
  46     using namespace std::chrono;
  47     auto time_value = steady_clock::now();
  48 #endif
  49     if (!AddFirstFrame())
  50       return 0;
  51
  52     ProcessSP process_sp(m_thread.GetProcess());
  53     ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
  54
  55     while (AddOneMoreFrame(abi)) {
  56 #if DEBUG_FRAME_SPEED
  57       if ((m_frames.size() % FRAME_COUNT) == 0) {
  58         const auto now = steady_clock::now();
  59         const auto delta_t = now - time_value;
  60         printf("%u frames in %.9f ms (%g frames/sec)\n", FRAME_COUNT,
  61                duration<double, std::milli>(delta_t).count(),
  62                (float)FRAME_COUNT / duration<double>(delta_t).count());
  63         time_value = now;
  64       }
  65 #endif
  66     }
  67   }
  68   return m_frames.size();
  69 }
  70
  71 bool UnwindLLDB::AddFirstFrame() {
  72   if (m_frames.size() > 0)
  73     return true;
  74
  75   ProcessSP process_sp(m_thread.GetProcess());
  76   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
  77
  78   // First, set up the 0th (initial) frame
  79   CursorSP first_cursor_sp(new Cursor());
  80   RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
  81       m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
  82   if (reg_ctx_sp.get() == nullptr)
  83     goto unwind_done;
  84
  85   if (!reg_ctx_sp->IsValid())
  86     goto unwind_done;
  87
  88   if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
  89     goto unwind_done;
  90
  91   if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
  92     goto unwind_done;
  93
  94   // Everything checks out, so release the auto pointer value and let the
  95   // cursor own it in its shared pointer
  96   first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
  97   m_frames.push_back(first_cursor_sp);
  98
  99   // Update the Full Unwind Plan for this frame if not valid
 100   UpdateUnwindPlanForFirstFrameIfInvalid(abi);
 101
 102   return true;
 103
 104 unwind_done:
 105   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 106   if (log) {
 107     LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
 108               m_thread.GetIndexID());
 109   }
 110   m_unwind_complete = true;
 111   return false;
 112 }
 113
 114 UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) {
 115   assert(m_frames.size() != 0 &&
 116          "Get one more frame called with empty frame list");
 117
 118   // If we've already gotten to the end of the stack, don't bother to try
 119   // again...
 120   if (m_unwind_complete)
 121     return nullptr;
 122
 123   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 124
 125   CursorSP prev_frame = m_frames.back();
 126   uint32_t cur_idx = m_frames.size();
 127
 128   CursorSP cursor_sp(new Cursor());
 129   RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
 130       m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
 131
 132   uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth();
 133
 134   // We want to detect an unwind that cycles erroneously and stop backtracing.
 135   // Don't want this maximum unwind limit to be too low -- if you have a
 136   // backtrace with an "infinitely recursing" bug, it will crash when the stack
 137   // blows out and the first 35,000 frames are uninteresting - it's the top
 138   // most 5 frames that you actually care about.  So you can't just cap the
 139   // unwind at 10,000 or something. Realistically anything over around 200,000
 140   // is going to blow out the stack space. If we're still unwinding at that
 141   // point, we're probably never going to finish.
 142   if (cur_idx >= max_stack_depth) {
 143     LLDB_LOGF(log,
 144               "%*sFrame %d unwound too many frames, assuming unwind has "
 145               "gone astray, stopping.",
 146               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 147     return nullptr;
 148   }
 149
 150   if (reg_ctx_sp.get() == nullptr) {
 151     // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
 152     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
 153     // return false.
 154     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 155       // TryFallbackUnwindPlan for prev_frame succeeded and updated
 156       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
 157       // still needs to be updated. Hence updating it.
 158       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 159         return nullptr;
 160
 161       return GetOneMoreFrame(abi);
 162     }
 163
 164     LLDB_LOGF(log, "%*sFrame %d did not get a RegisterContext, stopping.",
 165               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 166     return nullptr;
 167   }
 168
 169   if (!reg_ctx_sp->IsValid()) {
 170     // We failed to get a valid RegisterContext. See if the regctx below this
 171     // on the stack has a fallback unwind plan it can use. Subsequent calls to
 172     // TryFallbackUnwindPlan() will return false.
 173     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 174       // TryFallbackUnwindPlan for prev_frame succeeded and updated
 175       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
 176       // still needs to be updated. Hence updating it.
 177       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 178         return nullptr;
 179
 180       return GetOneMoreFrame(abi);
 181     }
 182
 183     LLDB_LOGF(log,
 184               "%*sFrame %d invalid RegisterContext for this frame, "
 185               "stopping stack walk",
 186               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 187     return nullptr;
 188   }
 189   if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
 190     // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
 191     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
 192     // return false.
 193     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 194       // TryFallbackUnwindPlan for prev_frame succeeded and updated
 195       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
 196       // still needs to be updated. Hence updating it.
 197       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 198         return nullptr;
 199
 200       return GetOneMoreFrame(abi);
 201     }
 202
 203     LLDB_LOGF(log,
 204               "%*sFrame %d did not get CFA for this frame, stopping stack walk",
 205               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 206     return nullptr;
 207   }
 208   if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
 209     // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
 210     // have its (constructed) CFA aligned correctly -- don't do the abi
 211     // alignment check for these.
 212     if (!reg_ctx_sp->IsTrapHandlerFrame()) {
 213       // See if we can find a fallback unwind plan for THIS frame.  It may be
 214       // that the UnwindPlan we're using for THIS frame was bad and gave us a
 215       // bad CFA. If that's not it, then see if we can change the UnwindPlan
 216       // for the frame below us ("NEXT") -- see if using that other UnwindPlan
 217       // gets us a better unwind state.
 218       if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
 219           !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
 220           !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
 221         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 222           // TryFallbackUnwindPlan for prev_frame succeeded and updated
 223           // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
 224           // prev_frame still needs to be updated. Hence updating it.
 225           if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 226             return nullptr;
 227
 228           return GetOneMoreFrame(abi);
 229         }
 230
 231         LLDB_LOGF(log,
 232                   "%*sFrame %d did not get a valid CFA for this frame, "
 233                   "stopping stack walk",
 234                   cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 235         return nullptr;
 236       } else {
 237         LLDB_LOGF(log,
 238                   "%*sFrame %d had a bad CFA value but we switched the "
 239                   "UnwindPlan being used and got one that looks more "
 240                   "realistic.",
 241                   cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 242       }
 243     }
 244   }
 245   if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
 246     // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
 247     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
 248     // return false.
 249     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 250       // TryFallbackUnwindPlan for prev_frame succeeded and updated
 251       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
 252       // still needs to be updated. Hence updating it.
 253       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 254         return nullptr;
 255
 256       return GetOneMoreFrame(abi);
 257     }
 258
 259     LLDB_LOGF(log,
 260               "%*sFrame %d did not get PC for this frame, stopping stack walk",
 261               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 262     return nullptr;
 263   }
 264   if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
 265     // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
 266     // that and return true.  Subsequent calls to TryFallbackUnwindPlan() will
 267     // return false.
 268     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 269       // TryFallbackUnwindPlan for prev_frame succeeded and updated
 270       // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
 271       // still needs to be updated. Hence updating it.
 272       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
 273         return nullptr;
 274
 275       return GetOneMoreFrame(abi);
 276     }
 277
 278     LLDB_LOGF(log, "%*sFrame %d did not get a valid PC, stopping stack walk",
 279               cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 280     return nullptr;
 281   }
 282   // Infinite loop where the current cursor is the same as the previous one...
 283   if (prev_frame->start_pc == cursor_sp->start_pc &&
 284       prev_frame->cfa == cursor_sp->cfa) {
 285     LLDB_LOGF(log,
 286               "th%d pc of this frame is the same as the previous frame and "
 287               "CFAs for both frames are identical -- stopping unwind",
 288               m_thread.GetIndexID());
 289     return nullptr;
 290   }
 291
 292   cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
 293   return cursor_sp;
 294 }
 295
 296 void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) {
 297   // This function is called for First Frame only.
 298   assert(m_frames.size() == 1 && "No. of cursor frames are not 1");
 299
 300   bool old_m_unwind_complete = m_unwind_complete;
 301   CursorSP old_m_candidate_frame = m_candidate_frame;
 302
 303   // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
 304   // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update
 305   // the cfa of Frame 0 (if required).
 306   AddOneMoreFrame(abi);
 307
 308   // Remove all the frames added by above function as the purpose of using
 309   // above function was just to check whether Unwinder of Frame 0 works or not.
 310   for (uint32_t i = 1; i < m_frames.size(); i++)
 311     m_frames.pop_back();
 312
 313   // Restore status after calling AddOneMoreFrame
 314   m_unwind_complete = old_m_unwind_complete;
 315   m_candidate_frame = old_m_candidate_frame;
 316   return;
 317 }
 318
 319 bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
 320   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 321
 322   // Frame zero is a little different
 323   if (m_frames.empty())
 324     return false;
 325
 326   // If we've already gotten to the end of the stack, don't bother to try
 327   // again...
 328   if (m_unwind_complete)
 329     return false;
 330
 331   CursorSP new_frame = m_candidate_frame;
 332   if (new_frame == nullptr)
 333     new_frame = GetOneMoreFrame(abi);
 334
 335   if (new_frame == nullptr) {
 336     LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
 337               m_thread.GetIndexID());
 338     m_unwind_complete = true;
 339     return false;
 340   }
 341
 342   m_frames.push_back(new_frame);
 343
 344   // If we can get one more frame further then accept that we get back a
 345   // correct frame.
 346   m_candidate_frame = GetOneMoreFrame(abi);
 347   if (m_candidate_frame)
 348     return true;
 349
 350   // We can't go further from the frame returned by GetOneMore frame. Lets try
 351   // to get a different frame with using the fallback unwind plan.
 352   if (!m_frames[m_frames.size() - 2]
 353            ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
 354     // We don't have a valid fallback unwind plan. Accept the frame as it is.
 355     // This is a valid situation when we are at the bottom of the stack.
 356     return true;
 357   }
 358
 359   // Remove the possibly incorrect frame from the frame list and try to add a
 360   // different one with the newly selected fallback unwind plan.
 361   m_frames.pop_back();
 362   CursorSP new_frame_v2 = GetOneMoreFrame(abi);
 363   if (new_frame_v2 == nullptr) {
 364     // We haven't got a new frame from the fallback unwind plan. Accept the
 365     // frame from the original unwind plan. This is a valid situation when we
 366     // are at the bottom of the stack.
 367     m_frames.push_back(new_frame);
 368     return true;
 369   }
 370
 371   // Push the new frame to the list and try to continue from this frame. If we
 372   // can get a new frame then accept it as the correct one.
 373   m_frames.push_back(new_frame_v2);
 374   m_candidate_frame = GetOneMoreFrame(abi);
 375   if (m_candidate_frame) {
 376     // If control reached here then TryFallbackUnwindPlan had succeeded for
 377     // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next
 378     // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For
 379     // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already
 380     // updated during TryFallbackUnwindPlan call above. However, cfa field
 381     // still needs to be updated. Hence updating it here and then returning.
 382     return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
 383         m_frames[m_frames.size() - 2]->cfa);
 384   }
 385
 386   // The new frame hasn't helped in unwinding. Fall back to the original one as
 387   // the default unwind plan is usually more reliable then the fallback one.
 388   m_frames.pop_back();
 389   m_frames.push_back(new_frame);
 390   return true;
 391 }
 392
 393 bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc,
 394                                        bool &behaves_like_zeroth_frame) {
 395   if (m_frames.size() == 0) {
 396     if (!AddFirstFrame())
 397       return false;
 398   }
 399
 400   ProcessSP process_sp(m_thread.GetProcess());
 401   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
 402
 403   while (idx >= m_frames.size() && AddOneMoreFrame(abi))
 404     ;
 405
 406   if (idx < m_frames.size()) {
 407     cfa = m_frames[idx]->cfa;
 408     pc = m_frames[idx]->start_pc;
 409     if (idx == 0) {
 410       // Frame zero always behaves like it.
 411       behaves_like_zeroth_frame = true;
 412     } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
 413       // This could be an asynchronous signal, thus the
 414       // pc might point to the interrupted instruction rather
 415       // than a post-call instruction
 416       behaves_like_zeroth_frame = true;
 417     } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
 418       // This frame may result from signal processing installing
 419       // a pointer to the first byte of a signal-return trampoline
 420       // in the return address slot of the frame below, so this
 421       // too behaves like the zeroth frame (i.e. the pc might not
 422       // be pointing just past a call in it)
 423       behaves_like_zeroth_frame = true;
 424     } else {
 425       behaves_like_zeroth_frame = false;
 426     }
 427     return true;
 428   }
 429   return false;
 430 }
 431
 432 lldb::RegisterContextSP
 433 UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
 434   lldb::RegisterContextSP reg_ctx_sp;
 435   uint32_t idx = frame->GetConcreteFrameIndex();
 436
 437   if (idx == 0) {
 438     return m_thread.GetRegisterContext();
 439   }
 440
 441   if (m_frames.size() == 0) {
 442     if (!AddFirstFrame())
 443       return reg_ctx_sp;
 444   }
 445
 446   ProcessSP process_sp(m_thread.GetProcess());
 447   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
 448
 449   while (idx >= m_frames.size()) {
 450     if (!AddOneMoreFrame(abi))
 451       break;
 452   }
 453
 454   const uint32_t num_frames = m_frames.size();
 455   if (idx < num_frames) {
 456     Cursor *frame_cursor = m_frames[idx].get();
 457     reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
 458   }
 459   return reg_ctx_sp;
 460 }
 461
 462 UnwindLLDB::RegisterContextLLDBSP
 463 UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) {
 464   RegisterContextLLDBSP reg_ctx_sp;
 465   if (frame_num < m_frames.size())
 466     reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
 467   return reg_ctx_sp;
 468 }
 469
 470 bool UnwindLLDB::SearchForSavedLocationForRegister(
 471     uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc,
 472     uint32_t starting_frame_num, bool pc_reg) {
 473   int64_t frame_num = starting_frame_num;
 474   if (static_cast<size_t>(frame_num) >= m_frames.size())
 475     return false;
 476
 477   // Never interrogate more than one level while looking for the saved pc
 478   // value. If the value isn't saved by frame_num, none of the frames lower on
 479   // the stack will have a useful value.
 480   if (pc_reg) {
 481     UnwindLLDB::RegisterSearchResult result;
 482     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
 483         lldb_regnum, regloc);
 484     return result == UnwindLLDB::RegisterSearchResult::eRegisterFound;
 485   }
 486   while (frame_num >= 0) {
 487     UnwindLLDB::RegisterSearchResult result;
 488     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
 489         lldb_regnum, regloc);
 490
 491     // We descended down to the live register context aka stack frame 0 and are
 492     // reading the value out of a live register.
 493     if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
 494         regloc.type ==
 495             UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) {
 496       return true;
 497     }
 498
 499     // If we have unwind instructions saying that register N is saved in
 500     // register M in the middle of the stack (and N can equal M here, meaning
 501     // the register was not used in this function), then change the register
 502     // number we're looking for to M and keep looking for a concrete  location
 503     // down the stack, or an actual value from a live RegisterContext at frame
 504     // 0.
 505     if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
 506         regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister &&
 507         frame_num > 0) {
 508       result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
 509       lldb_regnum = regloc.location.register_number;
 510     }
 511
 512     if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
 513       return true;
 514     if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)
 515       return false;
 516     frame_num--;
 517   }
 518   return false;
 519 }