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 {
  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 &regloc, 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 }