contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp

   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     m_user_supplied_trap_handler_functions()
  31 {
  32     ProcessSP process_sp(thread.GetProcess());
  33     if (process_sp)
  34     {
  35         Args args;
  36         process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames (args);
  37         size_t count = args.GetArgumentCount();
  38         for (size_t i = 0; i < count; i++)
  39         {
  40             const char *func_name = args.GetArgumentAtIndex(i);
  41             m_user_supplied_trap_handler_functions.push_back (ConstString (func_name));
  42         }
  43     }
  44 }
  45
  46 uint32_t
  47 UnwindLLDB::DoGetFrameCount()
  48 {
  49     if (!m_unwind_complete)
  50     {
  51 //#define DEBUG_FRAME_SPEED 1
  52 #if DEBUG_FRAME_SPEED
  53 #define FRAME_COUNT 10000
  54         TimeValue time_value (TimeValue::Now());
  55 #endif
  56         if (!AddFirstFrame ())
  57             return 0;
  58
  59         ProcessSP process_sp (m_thread.GetProcess());
  60         ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
  61
  62         while (AddOneMoreFrame (abi))
  63         {
  64 #if DEBUG_FRAME_SPEED
  65             if ((m_frames.size() % FRAME_COUNT) == 0)
  66             {
  67                 TimeValue now(TimeValue::Now());
  68                 uint64_t delta_t = now - time_value;
  69                 printf ("%u frames in %" PRIu64 ".%09llu ms (%g frames/sec)\n",
  70                         FRAME_COUNT,
  71                         delta_t / TimeValue::NanoSecPerSec,
  72                         delta_t % TimeValue::NanoSecPerSec,
  73                         (float)FRAME_COUNT / ((float)delta_t / (float)TimeValue::NanoSecPerSec));
  74                 time_value = now;
  75             }
  76 #endif
  77         }
  78     }
  79     return m_frames.size ();
  80 }
  81
  82 bool
  83 UnwindLLDB::AddFirstFrame ()
  84 {
  85     if (m_frames.size() > 0)
  86         return true;
  87
  88     // First, set up the 0th (initial) frame
  89     CursorSP first_cursor_sp(new Cursor ());
  90     RegisterContextLLDBSP reg_ctx_sp (new RegisterContextLLDB (m_thread,
  91                                                                RegisterContextLLDBSP(),
  92                                                                first_cursor_sp->sctx,
  93                                                                0, *this));
  94     if (reg_ctx_sp.get() == NULL)
  95         goto unwind_done;
  96
  97     if (!reg_ctx_sp->IsValid())
  98         goto unwind_done;
  99
 100     if (!reg_ctx_sp->GetCFA (first_cursor_sp->cfa))
 101         goto unwind_done;
 102
 103     if (!reg_ctx_sp->ReadPC (first_cursor_sp->start_pc))
 104         goto unwind_done;
 105
 106     // Everything checks out, so release the auto pointer value and let the
 107     // cursor own it in its shared pointer
 108     first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
 109     m_frames.push_back (first_cursor_sp);
 110     return true;
 111
 112 unwind_done:
 113     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 114     if (log)
 115     {
 116         log->Printf ("th%d Unwind of this thread is complete.", m_thread.GetIndexID());
 117     }
 118     m_unwind_complete = true;
 119     return false;
 120 }
 121
 122 // For adding a non-zero stack frame to m_frames.
 123 bool
 124 UnwindLLDB::AddOneMoreFrame (ABI *abi)
 125 {
 126     // If we've already gotten to the end of the stack, don't bother to try again...
 127     if (m_unwind_complete)
 128         return false;
 129
 130     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 131     CursorSP cursor_sp(new Cursor ());
 132
 133     // Frame zero is a little different
 134     if (m_frames.size() == 0)
 135         return false;
 136
 137     uint32_t cur_idx = m_frames.size ();
 138     RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB (m_thread,
 139                                                               m_frames[cur_idx - 1]->reg_ctx_lldb_sp,
 140                                                               cursor_sp->sctx,
 141                                                               cur_idx,
 142                                                               *this));
 143
 144     // We want to detect an unwind that cycles erronously and stop backtracing.
 145     // Don't want this maximum unwind limit to be too low -- if you have a backtrace
 146     // with an "infinitely recursing" bug, it will crash when the stack blows out
 147     // and the first 35,000 frames are uninteresting - it's the top most 5 frames that
 148     // you actually care about.  So you can't just cap the unwind at 10,000 or something.
 149     // Realistically anything over around 200,000 is going to blow out the stack space.
 150     // If we're still unwinding at that point, we're probably never going to finish.
 151     if (cur_idx > 300000)
 152     {
 153         if (log)
 154             log->Printf ("%*sFrame %d unwound too many frames, assuming unwind has gone astray, stopping.",
 155                          cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 156         goto unwind_done;
 157     }
 158
 159     if (reg_ctx_sp.get() == NULL)
 160     {
 161         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
 162         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
 163         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 164         {
 165             return AddOneMoreFrame (abi);
 166         }
 167         if (log)
 168             log->Printf ("%*sFrame %d did not get a RegisterContext, stopping.",
 169                          cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 170         goto unwind_done;
 171     }
 172
 173     if (!reg_ctx_sp->IsValid())
 174     {
 175         // We failed to get a valid RegisterContext.
 176         // See if the regctx below this on the stack has a fallback unwind plan it can use.
 177         // Subsequent calls to TryFallbackUnwindPlan() will return false.
 178         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 179         {
 180             return AddOneMoreFrame (abi);
 181         }
 182         if (log)
 183         {
 184             log->Printf("%*sFrame %d invalid RegisterContext for this frame, stopping stack walk",
 185                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 186         }
 187         goto unwind_done;
 188     }
 189     if (!reg_ctx_sp->GetCFA (cursor_sp->cfa))
 190     {
 191         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
 192         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
 193         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 194         {
 195             return AddOneMoreFrame (abi);
 196         }
 197         if (log)
 198         {
 199             log->Printf("%*sFrame %d did not get CFA for this frame, stopping stack walk",
 200                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 201         }
 202         goto unwind_done;
 203     }
 204     if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa))
 205     {
 206         // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not have
 207         // its (constructed) CFA aligned correctly -- don't do the abi alignment check for
 208         // these.
 209         if (reg_ctx_sp->IsTrapHandlerFrame() == false)
 210         {
 211             // See if we can find a fallback unwind plan for THIS frame.  It may be
 212             // that the UnwindPlan we're using for THIS frame was bad and gave us a
 213             // bad CFA.
 214             // If that's not it, then see if we can change the UnwindPlan for the frame
 215             // below us ("NEXT") -- see if using that other UnwindPlan gets us a better
 216             // unwind state.
 217             if (reg_ctx_sp->TryFallbackUnwindPlan() == false
 218                 || reg_ctx_sp->GetCFA (cursor_sp->cfa) == false
 219                 || abi->CallFrameAddressIsValid(cursor_sp->cfa) == false)
 220             {
 221                 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 222                 {
 223                     return AddOneMoreFrame (abi);
 224                 }
 225                 if (log)
 226                 {
 227                     log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk",
 228                                 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 229                 }
 230                 goto unwind_done;
 231             }
 232             else
 233             {
 234                 if (log)
 235                 {
 236                     log->Printf("%*sFrame %d had a bad CFA value but we switched the UnwindPlan being used and got one that looks more realistic.",
 237                                 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 238                 }
 239             }
 240         }
 241     }
 242     if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc))
 243     {
 244         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
 245         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
 246         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 247         {
 248             return AddOneMoreFrame (abi);
 249         }
 250         if (log)
 251         {
 252             log->Printf("%*sFrame %d did not get PC for this frame, stopping stack walk",
 253                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 254         }
 255         goto unwind_done;
 256     }
 257     if (abi && !abi->CodeAddressIsValid (cursor_sp->start_pc))
 258     {
 259         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
 260         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
 261         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
 262         {
 263             return AddOneMoreFrame (abi);
 264         }
 265         if (log)
 266         {
 267             log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk",
 268                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
 269         }
 270         goto unwind_done;
 271     }
 272     if (!m_frames.empty())
 273     {
 274         // Infinite loop where the current cursor is the same as the previous one...
 275         if (m_frames.back()->start_pc == cursor_sp->start_pc && m_frames.back()->cfa == cursor_sp->cfa)
 276         {
 277             if (log)
 278                 log->Printf ("th%d pc of this frame is the same as the previous frame and CFAs for both frames are identical -- stopping unwind", m_thread.GetIndexID());
 279             goto unwind_done;
 280         }
 281     }
 282
 283     cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
 284     m_frames.push_back (cursor_sp);
 285     return true;
 286
 287 unwind_done:
 288     if (log)
 289     {
 290         log->Printf ("th%d Unwind of this thread is complete.", m_thread.GetIndexID());
 291     }
 292     m_unwind_complete = true;
 293     return false;
 294 }
 295
 296 bool
 297 UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc)
 298 {
 299     if (m_frames.size() == 0)
 300     {
 301         if (!AddFirstFrame())
 302             return false;
 303     }
 304
 305     ProcessSP process_sp (m_thread.GetProcess());
 306     ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
 307
 308     while (idx >= m_frames.size() && AddOneMoreFrame (abi))
 309         ;
 310
 311     if (idx < m_frames.size ())
 312     {
 313         cfa = m_frames[idx]->cfa;
 314         pc = m_frames[idx]->start_pc;
 315         return true;
 316     }
 317     return false;
 318 }
 319
 320 lldb::RegisterContextSP
 321 UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame)
 322 {
 323     lldb::RegisterContextSP reg_ctx_sp;
 324     uint32_t idx = frame->GetConcreteFrameIndex ();
 325
 326     if (idx == 0)
 327     {
 328         return m_thread.GetRegisterContext();
 329     }
 330
 331     if (m_frames.size() == 0)
 332     {
 333         if (!AddFirstFrame())
 334             return reg_ctx_sp;
 335     }
 336
 337     ProcessSP process_sp (m_thread.GetProcess());
 338     ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
 339
 340     while (idx >= m_frames.size())
 341     {
 342         if (!AddOneMoreFrame (abi))
 343             break;
 344     }
 345
 346     const uint32_t num_frames = m_frames.size();
 347     if (idx < num_frames)
 348     {
 349         Cursor *frame_cursor = m_frames[idx].get();
 350         reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
 351     }
 352     return reg_ctx_sp;
 353 }
 354
 355 UnwindLLDB::RegisterContextLLDBSP
 356 UnwindLLDB::GetRegisterContextForFrameNum (uint32_t frame_num)
 357 {
 358     RegisterContextLLDBSP reg_ctx_sp;
 359     if (frame_num < m_frames.size())
 360         reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
 361     return reg_ctx_sp;
 362 }
 363
 364 bool
 365 UnwindLLDB::SearchForSavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc, uint32_t starting_frame_num, bool pc_reg)
 366 {
 367     int64_t frame_num = starting_frame_num;
 368     if (static_cast<size_t>(frame_num) >= m_frames.size())
 369         return false;
 370
 371     // Never interrogate more than one level while looking for the saved pc value.  If the value
 372     // isn't saved by frame_num, none of the frames lower on the stack will have a useful value.
 373     if (pc_reg)
 374     {
 375         UnwindLLDB::RegisterSearchResult result;
 376         result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc);
 377         if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
 378           return true;
 379         else
 380           return false;
 381     }
 382     while (frame_num >= 0)
 383     {
 384         UnwindLLDB::RegisterSearchResult result;
 385         result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc);
 386
 387         // We descended down to the live register context aka stack frame 0 and are reading the value
 388         // out of a live register.
 389         if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound
 390             && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext)
 391         {
 392             return true;
 393         }
 394
 395         // If we have unwind instructions saying that register N is saved in register M in the middle of
 396         // the stack (and N can equal M here, meaning the register was not used in this function), then
 397         // change the register number we're looking for to M and keep looking for a concrete  location
 398         // down the stack, or an actual value from a live RegisterContext at frame 0.
 399         if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound
 400             && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister
 401             && frame_num > 0)
 402         {
 403             result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
 404             lldb_regnum = regloc.location.register_number;
 405         }
 406
 407         if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
 408             return true;
 409         if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)
 410             return false;
 411         frame_num--;
 412     }
 413     return false;
 414 }