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

   1 //===-- RegisterContextLLDB.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
  11 #include "lldb/lldb-private.h"
  12 #include "lldb/Core/Address.h"
  13 #include "lldb/Core/AddressRange.h"
  14 #include "lldb/Core/DataBufferHeap.h"
  15 #include "lldb/Core/Log.h"
  16 #include "lldb/Core/Module.h"
  17 #include "lldb/Core/RegisterValue.h"
  18 #include "lldb/Core/Value.h"
  19 #include "lldb/Expression/DWARFExpression.h"
  20 #include "lldb/Symbol/DWARFCallFrameInfo.h"
  21 #include "lldb/Symbol/FuncUnwinders.h"
  22 #include "lldb/Symbol/Function.h"
  23 #include "lldb/Symbol/ObjectFile.h"
  24 #include "lldb/Symbol/SymbolContext.h"
  25 #include "lldb/Symbol/Symbol.h"
  26 #include "lldb/Target/ABI.h"
  27 #include "lldb/Target/ExecutionContext.h"
  28 #include "lldb/Target/Process.h"
  29 #include "lldb/Target/StackFrame.h"
  30 #include "lldb/Target/Target.h"
  31 #include "lldb/Target/Thread.h"
  32 #include "lldb/Target/DynamicLoader.h"
  33
  34 #include "RegisterContextLLDB.h"
  35
  36 using namespace lldb;
  37 using namespace lldb_private;
  38
  39 RegisterContextLLDB::RegisterContextLLDB
  40 (
  41     Thread& thread,
  42     const SharedPtr &next_frame,
  43     SymbolContext& sym_ctx,
  44     uint32_t frame_number,
  45     UnwindLLDB& unwind_lldb
  46 ) :
  47     RegisterContext (thread, frame_number),
  48     m_thread(thread),
  49     m_fast_unwind_plan_sp (),
  50     m_full_unwind_plan_sp (),
  51     m_all_registers_available(false),
  52     m_frame_type (-1),
  53     m_cfa (LLDB_INVALID_ADDRESS),
  54     m_start_pc (),
  55     m_current_pc (),
  56     m_current_offset (0),
  57     m_current_offset_backed_up_one (0),
  58     m_sym_ctx(sym_ctx),
  59     m_sym_ctx_valid (false),
  60     m_frame_number (frame_number),
  61     m_registers(),
  62     m_parent_unwind (unwind_lldb)
  63 {
  64     m_sym_ctx.Clear(false);
  65     m_sym_ctx_valid = false;
  66
  67     if (IsFrameZero ())
  68     {
  69         InitializeZerothFrame ();
  70     }
  71     else
  72     {
  73         InitializeNonZerothFrame ();
  74     }
  75
  76     // This same code exists over in the GetFullUnwindPlanForFrame() but it may not have been executed yet
  77     if (IsFrameZero()
  78         || next_frame->m_frame_type == eSigtrampFrame
  79         || next_frame->m_frame_type == eDebuggerFrame)
  80     {
  81         m_all_registers_available = true;
  82     }
  83 }
  84
  85 // Initialize a RegisterContextLLDB which is the first frame of a stack -- the zeroth frame or currently
  86 // executing frame.
  87
  88 void
  89 RegisterContextLLDB::InitializeZerothFrame()
  90 {
  91     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
  92     ExecutionContext exe_ctx(m_thread.shared_from_this());
  93     RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext();
  94
  95     if (reg_ctx_sp.get() == NULL)
  96     {
  97         m_frame_type = eNotAValidFrame;
  98         return;
  99     }
 100
 101     addr_t current_pc = reg_ctx_sp->GetPC();
 102
 103     if (current_pc == LLDB_INVALID_ADDRESS)
 104     {
 105         m_frame_type = eNotAValidFrame;
 106         return;
 107     }
 108
 109     Process *process = exe_ctx.GetProcessPtr();
 110
 111     // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
 112     // this will strip bit zero in case we read a PC from memory or from the LR.
 113     // (which would be a no-op in frame 0 where we get it from the register set,
 114     // but still a good idea to make the call here for other ABIs that may exist.)
 115     ABI *abi = process->GetABI().get();
 116     if (abi)
 117         current_pc = abi->FixCodeAddress(current_pc);
 118
 119     // Initialize m_current_pc, an Address object, based on current_pc, an addr_t.
 120     process->GetTarget().GetSectionLoadList().ResolveLoadAddress (current_pc, m_current_pc);
 121
 122     // If we don't have a Module for some reason, we're not going to find symbol/function information - just
 123     // stick in some reasonable defaults and hope we can unwind past this frame.
 124     ModuleSP pc_module_sp (m_current_pc.GetModule());
 125     if (!m_current_pc.IsValid() || !pc_module_sp)
 126     {
 127         UnwindLogMsg ("using architectural default unwind method");
 128     }
 129
 130     // We require that eSymbolContextSymbol be successfully filled in or this context is of no use to us.
 131     if (pc_module_sp.get()
 132         && (pc_module_sp->ResolveSymbolContextForAddress (m_current_pc, eSymbolContextFunction| eSymbolContextSymbol, m_sym_ctx) & eSymbolContextSymbol) == eSymbolContextSymbol)
 133     {
 134         m_sym_ctx_valid = true;
 135     }
 136
 137     AddressRange addr_range;
 138     m_sym_ctx.GetAddressRange (eSymbolContextFunction | eSymbolContextSymbol, 0, false, addr_range);
 139
 140     static ConstString g_sigtramp_name ("_sigtramp");
 141     if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == g_sigtramp_name) ||
 142         (m_sym_ctx.symbol   && m_sym_ctx.symbol->GetName()   == g_sigtramp_name))
 143     {
 144         m_frame_type = eSigtrampFrame;
 145     }
 146     else
 147     {
 148         // FIXME:  Detect eDebuggerFrame here.
 149         m_frame_type = eNormalFrame;
 150     }
 151
 152     // If we were able to find a symbol/function, set addr_range to the bounds of that symbol/function.
 153     // else treat the current pc value as the start_pc and record no offset.
 154     if (addr_range.GetBaseAddress().IsValid())
 155     {
 156         m_start_pc = addr_range.GetBaseAddress();
 157         if (m_current_pc.GetSection() == m_start_pc.GetSection())
 158         {
 159             m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
 160         }
 161         else if (m_current_pc.GetModule() == m_start_pc.GetModule())
 162         {
 163             // This means that whatever symbol we kicked up isn't really correct
 164             // --- we should not cross section boundaries ... We really should NULL out
 165             // the function/symbol in this case unless there is a bad assumption
 166             // here due to inlined functions?
 167             m_current_offset = m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress();
 168         }
 169         m_current_offset_backed_up_one = m_current_offset;
 170     }
 171     else
 172     {
 173         m_start_pc = m_current_pc;
 174         m_current_offset = -1;
 175         m_current_offset_backed_up_one = -1;
 176     }
 177
 178     // We've set m_frame_type and m_sym_ctx before these calls.
 179
 180     m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame ();
 181     m_full_unwind_plan_sp = GetFullUnwindPlanForFrame ();
 182
 183     UnwindPlan::RowSP active_row;
 184     int cfa_offset = 0;
 185     int row_register_kind = -1;
 186     if (m_full_unwind_plan_sp && m_full_unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 187     {
 188         active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
 189         row_register_kind = m_full_unwind_plan_sp->GetRegisterKind ();
 190         if (active_row.get() && log)
 191         {
 192             StreamString active_row_strm;
 193             active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread, m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
 194             UnwindLogMsg ("%s", active_row_strm.GetString().c_str());
 195         }
 196     }
 197
 198     if (!active_row.get())
 199     {
 200         m_frame_type = eNotAValidFrame;
 201         return;
 202     }
 203
 204
 205     addr_t cfa_regval = LLDB_INVALID_ADDRESS;
 206     if (!ReadGPRValue (row_register_kind, active_row->GetCFARegister(), cfa_regval))
 207     {
 208         m_frame_type = eNotAValidFrame;
 209         return;
 210     }
 211
 212     cfa_offset = active_row->GetCFAOffset ();
 213     m_cfa = cfa_regval + cfa_offset;
 214
 215     UnwindLogMsg ("cfa_regval = 0x%16.16" PRIx64 " (cfa_regval = 0x%16.16" PRIx64 ", cfa_offset = %i)", m_cfa, cfa_regval, cfa_offset);
 216     UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64 " using %s UnwindPlan",
 217             (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()),
 218             (uint64_t) m_cfa,
 219             m_full_unwind_plan_sp->GetSourceName().GetCString());
 220 }
 221
 222 // Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on the RegisterContextLLDB "below" it
 223 // to provide things like its current pc value.
 224
 225 void
 226 RegisterContextLLDB::InitializeNonZerothFrame()
 227 {
 228     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 229     if (IsFrameZero ())
 230     {
 231         m_frame_type = eNotAValidFrame;
 232         return;
 233     }
 234
 235     if (!GetNextFrame().get() || !GetNextFrame()->IsValid())
 236     {
 237         m_frame_type = eNotAValidFrame;
 238         return;
 239     }
 240     if (!m_thread.GetRegisterContext())
 241     {
 242         m_frame_type = eNotAValidFrame;
 243         return;
 244     }
 245
 246     addr_t pc;
 247     if (!ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc))
 248     {
 249         UnwindLogMsg ("could not get pc value");
 250         m_frame_type = eNotAValidFrame;
 251         return;
 252     }
 253
 254     if (log)
 255     {
 256         UnwindLogMsg ("pc = 0x%16.16" PRIx64, pc);
 257         addr_t reg_val;
 258         if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP, reg_val))
 259             UnwindLogMsg ("fp = 0x%16.16" PRIx64, reg_val);
 260         if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, reg_val))
 261             UnwindLogMsg ("sp = 0x%16.16" PRIx64, reg_val);
 262     }
 263
 264     // A pc of 0x0 means it's the end of the stack crawl
 265     if (pc == 0)
 266     {
 267         m_frame_type = eNotAValidFrame;
 268         return;
 269     }
 270
 271     ExecutionContext exe_ctx(m_thread.shared_from_this());
 272     Process *process = exe_ctx.GetProcessPtr();
 273     // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
 274     // this will strip bit zero in case we read a PC from memory or from the LR.
 275     ABI *abi = process->GetABI().get();
 276     if (abi)
 277         pc = abi->FixCodeAddress(pc);
 278
 279     process->GetTarget().GetSectionLoadList().ResolveLoadAddress (pc, m_current_pc);
 280
 281     // If we don't have a Module for some reason, we're not going to find symbol/function information - just
 282     // stick in some reasonable defaults and hope we can unwind past this frame.
 283     ModuleSP pc_module_sp (m_current_pc.GetModule());
 284     if (!m_current_pc.IsValid() || !pc_module_sp)
 285     {
 286         UnwindLogMsg ("using architectural default unwind method");
 287
 288         // Test the pc value to see if we know it's in an unmapped/non-executable region of memory.
 289         uint32_t permissions;
 290         if (process->GetLoadAddressPermissions(pc, permissions)
 291             && (permissions & ePermissionsExecutable) == 0)
 292         {
 293             // If this is the second frame off the stack, we may have unwound the first frame
 294             // incorrectly.  But using the architecture default unwind plan may get us back on
 295             // track -- albeit possibly skipping a real frame.  Give this frame a clearly-invalid
 296             // pc and see if we can get any further.
 297             if (GetNextFrame().get() && GetNextFrame()->IsValid() && GetNextFrame()->IsFrameZero())
 298             {
 299                 UnwindLogMsg ("had a pc of 0x%" PRIx64 " which is not in executable memory but on frame 1 -- allowing it once.",
 300                          (uint64_t) pc);
 301                 m_frame_type = eSkipFrame;
 302             }
 303             else
 304             {
 305                 // anywhere other than the second frame, a non-executable pc means we're off in the weeds -- stop now.
 306                 m_frame_type = eNotAValidFrame;
 307                 return;
 308             }
 309         }
 310
 311         if (abi)
 312         {
 313             m_fast_unwind_plan_sp.reset ();
 314             m_full_unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 315             abi->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp);
 316             if (m_frame_type != eSkipFrame)  // don't override eSkipFrame
 317             {
 318                 m_frame_type = eNormalFrame;
 319             }
 320             m_all_registers_available = false;
 321             m_current_offset = -1;
 322             m_current_offset_backed_up_one = -1;
 323             addr_t cfa_regval = LLDB_INVALID_ADDRESS;
 324             int row_register_kind = m_full_unwind_plan_sp->GetRegisterKind ();
 325             UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
 326             if (row.get())
 327             {
 328                 uint32_t cfa_regnum = row->GetCFARegister();
 329                 int cfa_offset = row->GetCFAOffset();
 330                 if (!ReadGPRValue (row_register_kind, cfa_regnum, cfa_regval))
 331                 {
 332                     UnwindLogMsg ("failed to get cfa value");
 333                     if (m_frame_type != eSkipFrame)   // don't override eSkipFrame
 334                     {
 335                         m_frame_type = eNormalFrame;
 336                     }
 337                     return;
 338                 }
 339                 m_cfa = cfa_regval + cfa_offset;
 340
 341                 // A couple of sanity checks..
 342                 if (cfa_regval == LLDB_INVALID_ADDRESS || cfa_regval == 0 || cfa_regval == 1)
 343                 {
 344                     UnwindLogMsg ("could not find a valid cfa address");
 345                     m_frame_type = eNotAValidFrame;
 346                     return;
 347                 }
 348
 349                 // cfa_regval should point into the stack memory; if we can query memory region permissions,
 350                 // see if the memory is allocated & readable.
 351                 if (process->GetLoadAddressPermissions(cfa_regval, permissions)
 352                     && (permissions & ePermissionsReadable) == 0)
 353                 {
 354                     m_frame_type = eNotAValidFrame;
 355                     return;
 356                 }
 357             }
 358             else
 359             {
 360                 UnwindLogMsg ("could not find a row for function offset zero");
 361                 m_frame_type = eNotAValidFrame;
 362                 return;
 363             }
 364
 365             UnwindLogMsg ("initialized frame cfa is 0x%" PRIx64, (uint64_t) m_cfa);
 366             return;
 367         }
 368         m_frame_type = eNotAValidFrame;
 369         return;
 370     }
 371
 372     // We require that eSymbolContextSymbol be successfully filled in or this context is of no use to us.
 373     if ((pc_module_sp->ResolveSymbolContextForAddress (m_current_pc, eSymbolContextFunction| eSymbolContextSymbol, m_sym_ctx) & eSymbolContextSymbol) == eSymbolContextSymbol)
 374     {
 375         m_sym_ctx_valid = true;
 376     }
 377
 378     AddressRange addr_range;
 379     if (!m_sym_ctx.GetAddressRange (eSymbolContextFunction | eSymbolContextSymbol, 0, false, addr_range))
 380     {
 381         m_sym_ctx_valid = false;
 382     }
 383
 384     bool decr_pc_and_recompute_addr_range = false;
 385
 386     // If the symbol lookup failed...
 387     if (m_sym_ctx_valid == false)
 388        decr_pc_and_recompute_addr_range = true;
 389
 390     // Or if we're in the middle of the stack (and not "above" an asynchronous event like sigtramp),
 391     // and our "current" pc is the start of a function...
 392     if (m_sym_ctx_valid
 393         && GetNextFrame()->m_frame_type != eSigtrampFrame
 394         && GetNextFrame()->m_frame_type != eDebuggerFrame
 395         && addr_range.GetBaseAddress().IsValid()
 396         && addr_range.GetBaseAddress().GetSection() == m_current_pc.GetSection()
 397         && addr_range.GetBaseAddress().GetOffset() == m_current_pc.GetOffset())
 398     {
 399         decr_pc_and_recompute_addr_range = true;
 400     }
 401
 402     // We need to back up the pc by 1 byte and re-search for the Symbol to handle the case where the "saved pc"
 403     // value is pointing to the next function, e.g. if a function ends with a CALL instruction.
 404     // FIXME this may need to be an architectural-dependent behavior; if so we'll need to add a member function
 405     // to the ABI plugin and consult that.
 406     if (decr_pc_and_recompute_addr_range)
 407     {
 408         Address temporary_pc(m_current_pc);
 409         temporary_pc.SetOffset(m_current_pc.GetOffset() - 1);
 410         m_sym_ctx.Clear(false);
 411         m_sym_ctx_valid = false;
 412         if ((pc_module_sp->ResolveSymbolContextForAddress (temporary_pc, eSymbolContextFunction| eSymbolContextSymbol, m_sym_ctx) & eSymbolContextSymbol) == eSymbolContextSymbol)
 413         {
 414             m_sym_ctx_valid = true;
 415         }
 416         if (!m_sym_ctx.GetAddressRange (eSymbolContextFunction | eSymbolContextSymbol, 0, false,  addr_range))
 417         {
 418             m_sym_ctx_valid = false;
 419         }
 420     }
 421
 422     // If we were able to find a symbol/function, set addr_range_ptr to the bounds of that symbol/function.
 423     // else treat the current pc value as the start_pc and record no offset.
 424     if (addr_range.GetBaseAddress().IsValid())
 425     {
 426         m_start_pc = addr_range.GetBaseAddress();
 427         m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
 428         m_current_offset_backed_up_one = m_current_offset;
 429         if (decr_pc_and_recompute_addr_range && m_current_offset_backed_up_one > 0)
 430         {
 431             m_current_offset_backed_up_one--;
 432             if (m_sym_ctx_valid)
 433                 m_current_pc.SetOffset(m_current_pc.GetOffset() - 1);
 434         }
 435     }
 436     else
 437     {
 438         m_start_pc = m_current_pc;
 439         m_current_offset = -1;
 440         m_current_offset_backed_up_one = -1;
 441     }
 442
 443     static ConstString sigtramp_name ("_sigtramp");
 444     if ((m_sym_ctx.function && m_sym_ctx.function->GetMangled().GetMangledName() == sigtramp_name)
 445         || (m_sym_ctx.symbol && m_sym_ctx.symbol->GetMangled().GetMangledName() == sigtramp_name))
 446     {
 447         m_frame_type = eSigtrampFrame;
 448     }
 449     else
 450     {
 451         // FIXME:  Detect eDebuggerFrame here.
 452         if (m_frame_type != eSkipFrame) // don't override eSkipFrame
 453         {
 454             m_frame_type = eNormalFrame;
 455         }
 456     }
 457
 458     // We've set m_frame_type and m_sym_ctx before this call.
 459     m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame ();
 460
 461     UnwindPlan::RowSP active_row;
 462     int cfa_offset = 0;
 463     int row_register_kind = -1;
 464
 465     // Try to get by with just the fast UnwindPlan if possible - the full UnwindPlan may be expensive to get
 466     // (e.g. if we have to parse the entire eh_frame section of an ObjectFile for the first time.)
 467
 468     if (m_fast_unwind_plan_sp && m_fast_unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 469     {
 470         active_row = m_fast_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
 471         row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind ();
 472         if (active_row.get() && log)
 473         {
 474             StreamString active_row_strm;
 475             active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread, m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
 476             UnwindLogMsg ("active row: %s", active_row_strm.GetString().c_str());
 477         }
 478     }
 479     else
 480     {
 481         m_full_unwind_plan_sp = GetFullUnwindPlanForFrame ();
 482         if (m_full_unwind_plan_sp && m_full_unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 483         {
 484             active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
 485             row_register_kind = m_full_unwind_plan_sp->GetRegisterKind ();
 486             if (active_row.get() && log)
 487             {
 488                 StreamString active_row_strm;
 489                 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread, m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
 490                 UnwindLogMsg ("active row: %s", active_row_strm.GetString().c_str());
 491             }
 492         }
 493     }
 494
 495     if (!active_row.get())
 496     {
 497         m_frame_type = eNotAValidFrame;
 498         return;
 499     }
 500
 501     addr_t cfa_regval = LLDB_INVALID_ADDRESS;
 502     if (!ReadGPRValue (row_register_kind, active_row->GetCFARegister(), cfa_regval))
 503     {
 504         UnwindLogMsg ("failed to get cfa reg %d/%d", row_register_kind, active_row->GetCFARegister());
 505         m_frame_type = eNotAValidFrame;
 506         return;
 507     }
 508
 509     cfa_offset = active_row->GetCFAOffset ();
 510     m_cfa = cfa_regval + cfa_offset;
 511
 512     UnwindLogMsg ("cfa_regval = 0x%16.16" PRIx64 " (cfa_regval = 0x%16.16" PRIx64 ", cfa_offset = %i)", m_cfa, cfa_regval, cfa_offset);
 513
 514     // A couple of sanity checks..
 515     if (cfa_regval == LLDB_INVALID_ADDRESS || cfa_regval == 0 || cfa_regval == 1)
 516     {
 517         UnwindLogMsg ("could not find a valid cfa address");
 518         m_frame_type = eNotAValidFrame;
 519         return;
 520     }
 521
 522     // If we have a bad stack setup, we can get the same CFA value multiple times -- or even
 523     // more devious, we can actually oscillate between two CFA values.  Detect that here and
 524     // break out to avoid a possible infinite loop in lldb trying to unwind the stack.
 525     addr_t next_frame_cfa;
 526     addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
 527     if (GetNextFrame().get() && GetNextFrame()->GetCFA(next_frame_cfa))
 528     {
 529         bool repeating_frames = false;
 530         if (next_frame_cfa == m_cfa)
 531         {
 532             repeating_frames = true;
 533         }
 534         else
 535         {
 536             if (GetNextFrame()->GetNextFrame() && GetNextFrame()->GetNextFrame()->GetCFA(next_next_frame_cfa)
 537                 && next_next_frame_cfa == m_cfa)
 538             {
 539                 repeating_frames = true;
 540             }
 541         }
 542         if (repeating_frames && abi->FunctionCallsChangeCFA())
 543         {
 544             UnwindLogMsg ("same CFA address as next frame, assuming the unwind is looping - stopping");
 545             m_frame_type = eNotAValidFrame;
 546             return;
 547         }
 548     }
 549
 550     UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64,
 551             (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()), (uint64_t) m_cfa);
 552 }
 553
 554
 555 bool
 556 RegisterContextLLDB::IsFrameZero () const
 557 {
 558     return m_frame_number == 0;
 559 }
 560
 561
 562 // Find a fast unwind plan for this frame, if possible.
 563 //
 564 // On entry to this method,
 565 //
 566 //   1. m_frame_type should already be set to eSigtrampFrame/eDebuggerFrame if either of those are correct,
 567 //   2. m_sym_ctx should already be filled in, and
 568 //   3. m_current_pc should have the current pc value for this frame
 569 //   4. m_current_offset_backed_up_one should have the current byte offset into the function, maybe backed up by 1, -1 if unknown
 570
 571 UnwindPlanSP
 572 RegisterContextLLDB::GetFastUnwindPlanForFrame ()
 573 {
 574     UnwindPlanSP unwind_plan_sp;
 575     ModuleSP pc_module_sp (m_current_pc.GetModule());
 576
 577     if (!m_current_pc.IsValid() || !pc_module_sp || pc_module_sp->GetObjectFile() == NULL)
 578         return unwind_plan_sp;
 579
 580     if (IsFrameZero ())
 581         return unwind_plan_sp;
 582
 583     FuncUnwindersSP func_unwinders_sp (pc_module_sp->GetObjectFile()->GetUnwindTable().GetFuncUnwindersContainingAddress (m_current_pc, m_sym_ctx));
 584     if (!func_unwinders_sp)
 585         return unwind_plan_sp;
 586
 587     // If we're in _sigtramp(), unwinding past this frame requires special knowledge.
 588     if (m_frame_type == eSigtrampFrame || m_frame_type == eDebuggerFrame)
 589         return unwind_plan_sp;
 590
 591     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind (m_thread);
 592     if (unwind_plan_sp)
 593     {
 594         if (unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 595         {
 596             Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 597             if (log && log->GetVerbose())
 598             {
 599                 if (m_fast_unwind_plan_sp)
 600                     UnwindLogMsgVerbose ("frame, and has a fast UnwindPlan");
 601                 else
 602                     UnwindLogMsgVerbose ("frame");
 603             }
 604             m_frame_type = eNormalFrame;
 605             return unwind_plan_sp;
 606         }
 607         else
 608         {
 609             unwind_plan_sp.reset();
 610         }
 611     }
 612     return unwind_plan_sp;
 613 }
 614
 615 // On entry to this method,
 616 //
 617 //   1. m_frame_type should already be set to eSigtrampFrame/eDebuggerFrame if either of those are correct,
 618 //   2. m_sym_ctx should already be filled in, and
 619 //   3. m_current_pc should have the current pc value for this frame
 620 //   4. m_current_offset_backed_up_one should have the current byte offset into the function, maybe backed up by 1, -1 if unknown
 621
 622 UnwindPlanSP
 623 RegisterContextLLDB::GetFullUnwindPlanForFrame ()
 624 {
 625     UnwindPlanSP unwind_plan_sp;
 626     UnwindPlanSP arch_default_unwind_plan_sp;
 627     ExecutionContext exe_ctx(m_thread.shared_from_this());
 628     Process *process = exe_ctx.GetProcessPtr();
 629     ABI *abi = process ? process->GetABI().get() : NULL;
 630     if (abi)
 631     {
 632         arch_default_unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 633         abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
 634     }
 635
 636     bool behaves_like_zeroth_frame = false;
 637     if (IsFrameZero ()
 638         || GetNextFrame()->m_frame_type == eSigtrampFrame
 639         || GetNextFrame()->m_frame_type == eDebuggerFrame)
 640     {
 641         behaves_like_zeroth_frame = true;
 642         // If this frame behaves like a 0th frame (currently executing or
 643         // interrupted asynchronously), all registers can be retrieved.
 644         m_all_registers_available = true;
 645     }
 646
 647     // If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer) so the pc is 0x0
 648     // in the zeroth frame, we need to use the "unwind at first instruction" arch default UnwindPlan
 649     // Also, if this Process can report on memory region attributes, any non-executable region means
 650     // we jumped through a bad function pointer - handle the same way as 0x0.
 651     // Note, if the symbol context has a function for the symbol, then we don't need to do this check.
 652
 653     if ((!m_sym_ctx_valid  || m_sym_ctx.function == NULL) && behaves_like_zeroth_frame && m_current_pc.IsValid())
 654     {
 655         uint32_t permissions;
 656         addr_t current_pc_addr = m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr());
 657         if (current_pc_addr == 0
 658             || (process->GetLoadAddressPermissions(current_pc_addr, permissions)
 659                 && (permissions & ePermissionsExecutable) == 0))
 660         {
 661             unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 662             abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
 663             m_frame_type = eNormalFrame;
 664             return unwind_plan_sp;
 665         }
 666     }
 667
 668     // No Module for the current pc, try using the architecture default unwind.
 669     ModuleSP pc_module_sp (m_current_pc.GetModule());
 670     if (!m_current_pc.IsValid() || !pc_module_sp || pc_module_sp->GetObjectFile() == NULL)
 671     {
 672         m_frame_type = eNormalFrame;
 673         return arch_default_unwind_plan_sp;
 674     }
 675
 676     FuncUnwindersSP func_unwinders_sp;
 677     if (m_sym_ctx_valid)
 678     {
 679         func_unwinders_sp = pc_module_sp->GetObjectFile()->GetUnwindTable().GetFuncUnwindersContainingAddress (m_current_pc, m_sym_ctx);
 680     }
 681
 682     // No FuncUnwinders available for this pc (i.e. a stripped function symbol and -fomit-frame-pointer).
 683     // Try using the eh_frame information relative to the current PC,
 684     // and finally fall back on the architectural default unwind.
 685     if (!func_unwinders_sp)
 686     {
 687         DWARFCallFrameInfo *eh_frame = pc_module_sp && pc_module_sp->GetObjectFile() ?
 688             pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo() : nullptr;
 689
 690         m_frame_type = eNormalFrame;
 691         if (eh_frame && m_current_pc.IsValid())
 692         {
 693             unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
 694             // Even with -fomit-frame-pointer, we can try eh_frame to get back on track.
 695             if (eh_frame->GetUnwindPlan (m_current_pc, *unwind_plan_sp))
 696                 return unwind_plan_sp;
 697             else
 698                 unwind_plan_sp.reset();
 699         }
 700         return arch_default_unwind_plan_sp;
 701     }
 702
 703     // If we're in _sigtramp(), unwinding past this frame requires special knowledge.  On Mac OS X this knowledge
 704     // is properly encoded in the eh_frame section, so prefer that if available.
 705     // On other platforms we may need to provide a platform-specific UnwindPlan which encodes the details of
 706     // how to unwind out of sigtramp.
 707     if (m_frame_type == eSigtrampFrame)
 708     {
 709         m_fast_unwind_plan_sp.reset();
 710         unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
 711         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 712             return unwind_plan_sp;
 713     }
 714
 715     // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame even when it's frame zero
 716     // This comes up if we have hand-written functions in a Module and hand-written eh_frame.  The assembly
 717     // instruction inspection may fail and the eh_frame CFI were probably written with some care to do the
 718     // right thing.  It'd be nice if there was a way to ask the eh_frame directly if it is asynchronous
 719     // (can be trusted at every instruction point) or synchronous (the normal case - only at call sites).
 720     // But there is not.
 721     if (process && process->GetDynamicLoader() && process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo (m_sym_ctx))
 722     {
 723         unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
 724         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 725         {
 726             UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan because the DynamicLoader suggested we prefer it",
 727                            unwind_plan_sp->GetSourceName().GetCString());
 728             return unwind_plan_sp;
 729         }
 730     }
 731
 732     // Typically the NonCallSite UnwindPlan is the unwind created by inspecting the assembly language instructions
 733     if (behaves_like_zeroth_frame)
 734     {
 735         unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite (m_thread);
 736         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 737         {
 738             UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan", unwind_plan_sp->GetSourceName().GetCString());
 739             return unwind_plan_sp;
 740         }
 741     }
 742
 743     // Typically this is unwind info from an eh_frame section intended for exception handling; only valid at call sites
 744     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
 745     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 746     {
 747         UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan", unwind_plan_sp->GetSourceName().GetCString());
 748         return unwind_plan_sp;
 749     }
 750
 751     // We'd prefer to use an UnwindPlan intended for call sites when we're at a call site but if we've
 752     // struck out on that, fall back to using the non-call-site assembly inspection UnwindPlan if possible.
 753     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite (m_thread);
 754     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
 755     {
 756         UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan", unwind_plan_sp->GetSourceName().GetCString());
 757         return unwind_plan_sp;
 758     }
 759
 760     // If nothing else, use the architectural default UnwindPlan and hope that does the job.
 761     UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan", arch_default_unwind_plan_sp->GetSourceName().GetCString());
 762     return arch_default_unwind_plan_sp;
 763 }
 764
 765
 766 void
 767 RegisterContextLLDB::InvalidateAllRegisters ()
 768 {
 769     m_frame_type = eNotAValidFrame;
 770 }
 771
 772 size_t
 773 RegisterContextLLDB::GetRegisterCount ()
 774 {
 775     return m_thread.GetRegisterContext()->GetRegisterCount();
 776 }
 777
 778 const RegisterInfo *
 779 RegisterContextLLDB::GetRegisterInfoAtIndex (size_t reg)
 780 {
 781     return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex (reg);
 782 }
 783
 784 size_t
 785 RegisterContextLLDB::GetRegisterSetCount ()
 786 {
 787     return m_thread.GetRegisterContext()->GetRegisterSetCount ();
 788 }
 789
 790 const RegisterSet *
 791 RegisterContextLLDB::GetRegisterSet (size_t reg_set)
 792 {
 793     return m_thread.GetRegisterContext()->GetRegisterSet (reg_set);
 794 }
 795
 796 uint32_t
 797 RegisterContextLLDB::ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num)
 798 {
 799     return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber (kind, num);
 800 }
 801
 802 bool
 803 RegisterContextLLDB::ReadRegisterValueFromRegisterLocation (lldb_private::UnwindLLDB::RegisterLocation regloc,
 804                                                             const RegisterInfo *reg_info,
 805                                                             RegisterValue &value)
 806 {
 807     if (!IsValid())
 808         return false;
 809     bool success = false;
 810
 811     switch (regloc.type)
 812     {
 813     case UnwindLLDB::RegisterLocation::eRegisterInRegister:
 814         {
 815             const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
 816
 817             if (!other_reg_info)
 818                 return false;
 819
 820             if (IsFrameZero ())
 821             {
 822                 success = m_thread.GetRegisterContext()->ReadRegister (other_reg_info, value);
 823             }
 824             else
 825             {
 826                 success = GetNextFrame()->ReadRegister (other_reg_info, value);
 827             }
 828         }
 829         break;
 830     case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
 831         success = value.SetUInt (regloc.location.inferred_value, reg_info->byte_size);
 832         break;
 833
 834     case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
 835         break;
 836     case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
 837         assert ("FIXME debugger inferior function call unwind");
 838         break;
 839     case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation:
 840         {
 841             Error error (ReadRegisterValueFromMemory(reg_info,
 842                                                      regloc.location.target_memory_location,
 843                                                      reg_info->byte_size,
 844                                                      value));
 845             success = error.Success();
 846         }
 847         break;
 848     default:
 849         assert ("Unknown RegisterLocation type.");
 850         break;
 851     }
 852     return success;
 853 }
 854
 855 bool
 856 RegisterContextLLDB::WriteRegisterValueToRegisterLocation (lldb_private::UnwindLLDB::RegisterLocation regloc,
 857                                                            const RegisterInfo *reg_info,
 858                                                            const RegisterValue &value)
 859 {
 860     if (!IsValid())
 861         return false;
 862
 863     bool success = false;
 864
 865     switch (regloc.type)
 866     {
 867         case UnwindLLDB::RegisterLocation::eRegisterInRegister:
 868             {
 869                 const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
 870                 if (IsFrameZero ())
 871                 {
 872                     success = m_thread.GetRegisterContext()->WriteRegister (other_reg_info, value);
 873                 }
 874                 else
 875                 {
 876                     success = GetNextFrame()->WriteRegister (other_reg_info, value);
 877                 }
 878             }
 879             break;
 880         case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
 881         case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
 882             break;
 883         case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
 884             assert ("FIXME debugger inferior function call unwind");
 885             break;
 886         case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation:
 887             {
 888                 Error error (WriteRegisterValueToMemory (reg_info,
 889                                                          regloc.location.target_memory_location,
 890                                                          reg_info->byte_size,
 891                                                          value));
 892                 success = error.Success();
 893             }
 894             break;
 895         default:
 896             assert ("Unknown RegisterLocation type.");
 897             break;
 898     }
 899     return success;
 900 }
 901
 902
 903 bool
 904 RegisterContextLLDB::IsValid () const
 905 {
 906     return m_frame_type != eNotAValidFrame;
 907 }
 908
 909 // A skip frame is a bogus frame on the stack -- but one where we're likely to find a real frame farther
 910 // up the stack if we keep looking.  It's always the second frame in an unwind (i.e. the first frame after
 911 // frame zero) where unwinding can be the trickiest.  Ideally we'll mark up this frame in some way so the
 912 // user knows we're displaying bad data and we may have skipped one frame of their real program in the
 913 // process of getting back on track.
 914
 915 bool
 916 RegisterContextLLDB::IsSkipFrame () const
 917 {
 918     return m_frame_type == eSkipFrame;
 919 }
 920
 921 // Answer the question: Where did THIS frame save the CALLER frame ("previous" frame)'s register value?
 922
 923 enum UnwindLLDB::RegisterSearchResult
 924 RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc)
 925 {
 926     // Have we already found this register location?
 927     if (!m_registers.empty())
 928     {
 929         std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation>::const_iterator iterator;
 930         iterator = m_registers.find (lldb_regnum);
 931         if (iterator != m_registers.end())
 932         {
 933             regloc = iterator->second;
 934             UnwindLogMsg ("supplying caller's saved reg %d's location, cached", lldb_regnum);
 935             return UnwindLLDB::RegisterSearchResult::eRegisterFound;
 936         }
 937     }
 938
 939     uint32_t sp_regnum = LLDB_INVALID_REGNUM;
 940     uint32_t pc_regnum = LLDB_INVALID_REGNUM;
 941     m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, eRegisterKindLLDB, sp_regnum);
 942     m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, eRegisterKindLLDB, pc_regnum);
 943
 944     // Are we looking for the CALLER's stack pointer?  The stack pointer is defined to be the same as THIS frame's
 945     // CFA so just return the CFA value.  This is true on x86-32/x86-64 at least.
 946     if (sp_regnum != LLDB_INVALID_REGNUM && sp_regnum == lldb_regnum)
 947     {
 948         // make sure we won't lose precision copying an addr_t (m_cfa) into a uint64_t (.inferred_value)
 949         assert (sizeof (addr_t) <= sizeof (uint64_t));
 950         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
 951         regloc.location.inferred_value = m_cfa;
 952         m_registers[lldb_regnum] = regloc;
 953         UnwindLogMsg ("supplying caller's stack pointer (%d) value, computed from CFA", lldb_regnum);
 954         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
 955     }
 956
 957     // Look through the available UnwindPlans for the register location.
 958
 959     UnwindPlan::Row::RegisterLocation unwindplan_regloc;
 960     bool have_unwindplan_regloc = false;
 961     RegisterKind unwindplan_registerkind = (RegisterKind)-1;
 962
 963     if (m_fast_unwind_plan_sp)
 964     {
 965         UnwindPlan::RowSP active_row = m_fast_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
 966         unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind ();
 967         uint32_t row_regnum;
 968         if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindLLDB, lldb_regnum, unwindplan_registerkind, row_regnum))
 969         {
 970             UnwindLogMsg ("could not convert lldb regnum %d into %d RegisterKind reg numbering scheme",
 971                     lldb_regnum, (int) unwindplan_registerkind);
 972             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
 973         }
 974         if (active_row->GetRegisterInfo (row_regnum, unwindplan_regloc))
 975         {
 976             UnwindLogMsg ("supplying caller's saved reg %d's location using FastUnwindPlan", lldb_regnum);
 977             have_unwindplan_regloc = true;
 978         }
 979     }
 980
 981     if (!have_unwindplan_regloc)
 982     {
 983         // m_full_unwind_plan_sp being NULL means that we haven't tried to find a full UnwindPlan yet
 984         if (!m_full_unwind_plan_sp)
 985             m_full_unwind_plan_sp = GetFullUnwindPlanForFrame ();
 986
 987         if (m_full_unwind_plan_sp)
 988         {
 989             UnwindPlan::RowSP active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
 990             unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind ();
 991             uint32_t row_regnum;
 992             bool row_register_rewritten_to_return_address_reg = false;
 993
 994             // If we're fetching the saved pc and this UnwindPlan defines a ReturnAddress register (e.g. lr on arm),
 995             // look for the return address register number in the UnwindPlan's row.
 996             if (lldb_regnum == pc_regnum && m_full_unwind_plan_sp->GetReturnAddressRegister() != LLDB_INVALID_REGNUM)
 997             {
 998                row_regnum = m_full_unwind_plan_sp->GetReturnAddressRegister();
 999                row_register_rewritten_to_return_address_reg = true;
1000                UnwindLogMsg ("requested caller's saved PC but this UnwindPlan uses a RA reg; getting reg %d instead",
1001                        row_regnum);
1002             }
1003             else
1004             {
1005                 if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindLLDB, lldb_regnum, unwindplan_registerkind, row_regnum))
1006                 {
1007                     if (unwindplan_registerkind == eRegisterKindGeneric)
1008                         UnwindLogMsg ("could not convert lldb regnum %d into eRegisterKindGeneric reg numbering scheme", lldb_regnum);
1009                     else
1010                         UnwindLogMsg ("could not convert lldb regnum %d into %d RegisterKind reg numbering scheme",
1011                                 lldb_regnum, (int) unwindplan_registerkind);
1012                     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1013                 }
1014             }
1015
1016             if (active_row->GetRegisterInfo (row_regnum, unwindplan_regloc))
1017             {
1018                 have_unwindplan_regloc = true;
1019                 UnwindLogMsg ("supplying caller's saved reg %d's location using %s UnwindPlan", lldb_regnum,
1020                               m_full_unwind_plan_sp->GetSourceName().GetCString());
1021             }
1022
1023             // This is frame 0 and we're retrieving the PC and it's saved in a Return Address register and
1024             // it hasn't been saved anywhere yet -- that is, it's still live in the actual register.
1025             // Handle this specially.
1026
1027             if (have_unwindplan_regloc == false
1028                 && row_register_rewritten_to_return_address_reg == true
1029                 && IsFrameZero()
1030                 && row_regnum != LLDB_INVALID_REGNUM)
1031             {
1032                 uint32_t ra_regnum_in_lldb_reg_numbering;
1033                 if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (unwindplan_registerkind, row_regnum, eRegisterKindLLDB, ra_regnum_in_lldb_reg_numbering))
1034                 {
1035                     lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1036                     new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1037                     new_regloc.location.register_number = ra_regnum_in_lldb_reg_numbering;
1038                     m_registers[lldb_regnum] = new_regloc;
1039                     regloc = new_regloc;
1040                     UnwindLogMsg ("supplying caller's register %d from the live RegisterContext at frame 0, saved in %d", lldb_regnum, ra_regnum_in_lldb_reg_numbering);
1041                     return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1042                 }
1043             }
1044
1045             // If this architecture stores the return address in a register (it defines a Return Address register)
1046             // and we're on a non-zero stack frame and the Full UnwindPlan says that the pc is stored in the
1047             // RA registers (e.g. lr on arm), then we know that the full unwindplan is not trustworthy -- this
1048             // is an impossible situation and the instruction emulation code has likely been misled.
1049             // If this stack frame meets those criteria, we need to throw away the Full UnwindPlan that the
1050             // instruction emulation came up with and fall back to the architecture's Default UnwindPlan so
1051             // the stack walk can get past this point.
1052
1053             // Special note:  If the Full UnwindPlan was generated from the compiler, don't second-guess it
1054             // when we're at a call site location.
1055
1056             // arch_default_ra_regnum is the return address register # in the Full UnwindPlan register numbering
1057             uint32_t arch_default_ra_regnum = LLDB_INVALID_REGNUM;
1058             if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, unwindplan_registerkind, arch_default_ra_regnum)
1059                 && arch_default_ra_regnum != LLDB_INVALID_REGNUM
1060                 && pc_regnum != LLDB_INVALID_REGNUM
1061                 && pc_regnum == lldb_regnum
1062                 && unwindplan_regloc.IsInOtherRegister()
1063                 && unwindplan_regloc.GetRegisterNumber() == arch_default_ra_regnum
1064                 && m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes
1065                 && !m_all_registers_available)
1066             {
1067                 UnwindLogMsg ("%s UnwindPlan tried to restore the pc from the link register but this is a non-zero frame",
1068                               m_full_unwind_plan_sp->GetSourceName().GetCString());
1069
1070                 // Throw away the full unwindplan; install the arch default unwindplan
1071                 InvalidateFullUnwindPlan();
1072
1073                 // Now re-fetch the pc value we're searching for
1074                 uint32_t arch_default_pc_reg = LLDB_INVALID_REGNUM;
1075                 UnwindPlan::RowSP active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
1076                 if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, m_full_unwind_plan_sp->GetRegisterKind(), arch_default_pc_reg)
1077                     && arch_default_pc_reg != LLDB_INVALID_REGNUM
1078                     && active_row
1079                     && active_row->GetRegisterInfo (arch_default_pc_reg, unwindplan_regloc))
1080                 {
1081                     have_unwindplan_regloc = true;
1082                 }
1083                 else
1084                 {
1085                     have_unwindplan_regloc = false;
1086                 }
1087             }
1088         }
1089     }
1090
1091
1092     ExecutionContext exe_ctx(m_thread.shared_from_this());
1093     Process *process = exe_ctx.GetProcessPtr();
1094     if (have_unwindplan_regloc == false)
1095     {
1096         // If a volatile register is being requested, we don't want to forward the next frame's register contents
1097         // up the stack -- the register is not retrievable at this frame.
1098         ABI *abi = process ? process->GetABI().get() : NULL;
1099         if (abi)
1100         {
1101             const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
1102             if (reg_info && abi->RegisterIsVolatile (reg_info))
1103             {
1104                 UnwindLogMsg ("did not supply reg location for %d because it is volatile", lldb_regnum);
1105                 return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile;
1106             }
1107         }
1108
1109         if (IsFrameZero ())
1110         {
1111             // This is frame 0 - we should return the actual live register context value
1112             lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1113             new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1114             new_regloc.location.register_number = lldb_regnum;
1115             m_registers[lldb_regnum] = new_regloc;
1116             regloc = new_regloc;
1117             UnwindLogMsg ("supplying caller's register %d from the live RegisterContext at frame 0", lldb_regnum);
1118             return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1119         }
1120         else
1121         UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
1122         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1123     }
1124
1125     // unwindplan_regloc has valid contents about where to retrieve the register
1126     if (unwindplan_regloc.IsUnspecified())
1127     {
1128         lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1129         new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
1130         m_registers[lldb_regnum] = new_regloc;
1131         UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
1132         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1133     }
1134
1135     if (unwindplan_regloc.IsSame())
1136     {
1137         if (IsFrameZero ())
1138         {
1139             UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
1140             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1141         }
1142         else
1143         {
1144             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1145         }
1146     }
1147
1148     if (unwindplan_regloc.IsCFAPlusOffset())
1149     {
1150         int offset = unwindplan_regloc.GetOffset();
1151         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1152         regloc.location.inferred_value = m_cfa + offset;
1153         m_registers[lldb_regnum] = regloc;
1154         UnwindLogMsg ("supplying caller's register %d, value is CFA plus offset", lldb_regnum);
1155         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1156     }
1157
1158     if (unwindplan_regloc.IsAtCFAPlusOffset())
1159     {
1160         int offset = unwindplan_regloc.GetOffset();
1161         regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1162         regloc.location.target_memory_location = m_cfa + offset;
1163         m_registers[lldb_regnum] = regloc;
1164         UnwindLogMsg ("supplying caller's register %d from the stack, saved at CFA plus offset", lldb_regnum);
1165         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1166     }
1167
1168     if (unwindplan_regloc.IsInOtherRegister())
1169     {
1170         uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
1171         uint32_t row_regnum_in_lldb;
1172         if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (unwindplan_registerkind, unwindplan_regnum, eRegisterKindLLDB, row_regnum_in_lldb))
1173         {
1174             UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
1175             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1176         }
1177         regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1178         regloc.location.register_number = row_regnum_in_lldb;
1179         m_registers[lldb_regnum] = regloc;
1180         UnwindLogMsg ("supplying caller's register %d, saved in register %d", lldb_regnum, row_regnum_in_lldb);
1181         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1182     }
1183
1184     if (unwindplan_regloc.IsDWARFExpression() || unwindplan_regloc.IsAtDWARFExpression())
1185     {
1186         DataExtractor dwarfdata (unwindplan_regloc.GetDWARFExpressionBytes(),
1187                                  unwindplan_regloc.GetDWARFExpressionLength(),
1188                                  process->GetByteOrder(), process->GetAddressByteSize());
1189         DWARFExpression dwarfexpr (dwarfdata, 0, unwindplan_regloc.GetDWARFExpressionLength());
1190         dwarfexpr.SetRegisterKind (unwindplan_registerkind);
1191         Value result;
1192         Error error;
1193         if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
1194         {
1195             addr_t val;
1196             val = result.GetScalar().ULongLong();
1197             if (unwindplan_regloc.IsDWARFExpression())
1198              {
1199                 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1200                 regloc.location.inferred_value = val;
1201                 m_registers[lldb_regnum] = regloc;
1202                 UnwindLogMsg ("supplying caller's register %d via DWARF expression (IsDWARFExpression)", lldb_regnum);
1203                 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1204             }
1205             else
1206             {
1207                 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1208                 regloc.location.target_memory_location = val;
1209                 m_registers[lldb_regnum] = regloc;
1210                 UnwindLogMsg ("supplying caller's register %d via DWARF expression (IsAtDWARFExpression)", lldb_regnum);
1211                 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1212             }
1213         }
1214         UnwindLogMsg ("tried to use IsDWARFExpression or IsAtDWARFExpression for reg %d but failed", lldb_regnum);
1215         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1216     }
1217
1218     UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
1219
1220     // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are unsupported.
1221
1222     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1223 }
1224
1225 // If the Full unwindplan has been determined to be incorrect, this method will
1226 // replace it with the architecture's default unwindplna, if one is defined.
1227 // It will also find the FuncUnwinders object for this function and replace the
1228 // Full unwind method for the function there so we don't use the errant Full unwindplan
1229 // again in the future of this debug session.
1230 // We're most likely doing this because the Full unwindplan was generated by assembly
1231 // instruction profiling and the profiler got something wrong.
1232
1233 void
1234 RegisterContextLLDB::InvalidateFullUnwindPlan ()
1235 {
1236     UnwindPlan::Row::RegisterLocation unwindplan_regloc;
1237     ExecutionContext exe_ctx (m_thread.shared_from_this());
1238     Process *process = exe_ctx.GetProcessPtr();
1239     ABI *abi = process ? process->GetABI().get() : NULL;
1240     if (abi)
1241     {
1242         UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
1243         UnwindPlanSP arch_default_unwind_plan_sp;
1244         arch_default_unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
1245         abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
1246         if (arch_default_unwind_plan_sp)
1247         {
1248             UnwindPlan::RowSP active_row = arch_default_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
1249
1250             if (active_row && active_row->GetCFARegister() != LLDB_INVALID_REGNUM)
1251             {
1252                 FuncUnwindersSP func_unwinders_sp;
1253                 if (m_sym_ctx_valid && m_current_pc.IsValid() && m_current_pc.GetModule())
1254                 {
1255                     func_unwinders_sp = m_current_pc.GetModule()->GetObjectFile()->GetUnwindTable().GetFuncUnwindersContainingAddress (m_current_pc, m_sym_ctx);
1256                     if (func_unwinders_sp)
1257                     {
1258                         func_unwinders_sp->InvalidateNonCallSiteUnwindPlan (m_thread);
1259                     }
1260                 }
1261                 m_registers.clear();
1262                 m_full_unwind_plan_sp = arch_default_unwind_plan_sp;
1263                 addr_t cfa_regval = LLDB_INVALID_ADDRESS;
1264                 if (ReadGPRValue (arch_default_unwind_plan_sp->GetRegisterKind(), active_row->GetCFARegister(), cfa_regval))
1265                 {
1266                     m_cfa = cfa_regval + active_row->GetCFAOffset ();
1267                 }
1268
1269                 UnwindLogMsg ("full unwind plan '%s' has been replaced by architecture default unwind plan '%s' for this function from now on.",
1270                               original_full_unwind_plan_sp->GetSourceName().GetCString(), arch_default_unwind_plan_sp->GetSourceName().GetCString());
1271             }
1272         }
1273     }
1274 }
1275
1276 // Retrieve a general purpose register value for THIS frame, as saved by the NEXT frame, i.e. the frame that
1277 // this frame called.  e.g.
1278 //
1279 //  foo () { }
1280 //  bar () { foo (); }
1281 //  main () { bar (); }
1282 //
1283 //  stopped in foo() so
1284 //     frame 0 - foo
1285 //     frame 1 - bar
1286 //     frame 2 - main
1287 //  and this RegisterContext is for frame 1 (bar) - if we want to get the pc value for frame 1, we need to ask
1288 //  where frame 0 (the "next" frame) saved that and retrieve the value.
1289
1290 bool
1291 RegisterContextLLDB::ReadGPRValue (int register_kind, uint32_t regnum, addr_t &value)
1292 {
1293     if (!IsValid())
1294         return false;
1295
1296     uint32_t lldb_regnum;
1297     if (register_kind == eRegisterKindLLDB)
1298     {
1299         lldb_regnum = regnum;
1300     }
1301     else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (register_kind, regnum, eRegisterKindLLDB, lldb_regnum))
1302     {
1303         return false;
1304     }
1305
1306     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
1307     RegisterValue reg_value;
1308     // if this is frame 0 (currently executing frame), get the requested reg contents from the actual thread registers
1309     if (IsFrameZero ())
1310     {
1311         if (m_thread.GetRegisterContext()->ReadRegister (reg_info, reg_value))
1312         {
1313             value = reg_value.GetAsUInt64();
1314             return true;
1315         }
1316         return false;
1317     }
1318
1319     bool pc_register = false;
1320     uint32_t generic_regnum;
1321     if (register_kind == eRegisterKindGeneric && regnum == LLDB_REGNUM_GENERIC_PC)
1322     {
1323         pc_register = true;
1324     }
1325     else if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (register_kind, regnum, eRegisterKindGeneric, generic_regnum)
1326              && generic_regnum == LLDB_REGNUM_GENERIC_PC)
1327     {
1328         pc_register = true;
1329     }
1330
1331     lldb_private::UnwindLLDB::RegisterLocation regloc;
1332     if (!m_parent_unwind.SearchForSavedLocationForRegister (lldb_regnum, regloc, m_frame_number - 1, pc_register))
1333     {
1334         return false;
1335     }
1336     if (ReadRegisterValueFromRegisterLocation (regloc, reg_info, reg_value))
1337     {
1338         value = reg_value.GetAsUInt64();
1339         return true;
1340     }
1341     return false;
1342 }
1343
1344 // Find the value of a register in THIS frame
1345
1346 bool
1347 RegisterContextLLDB::ReadRegister (const RegisterInfo *reg_info, RegisterValue &value)
1348 {
1349     if (!IsValid())
1350         return false;
1351
1352     const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
1353     UnwindLogMsgVerbose ("looking for register saved location for reg %d", lldb_regnum);
1354
1355     // If this is the 0th frame, hand this over to the live register context
1356     if (IsFrameZero ())
1357     {
1358         UnwindLogMsgVerbose ("passing along to the live register context for reg %d", lldb_regnum);
1359         return m_thread.GetRegisterContext()->ReadRegister (reg_info, value);
1360     }
1361
1362     lldb_private::UnwindLLDB::RegisterLocation regloc;
1363     // Find out where the NEXT frame saved THIS frame's register contents
1364     if (!m_parent_unwind.SearchForSavedLocationForRegister (lldb_regnum, regloc, m_frame_number - 1, false))
1365         return false;
1366
1367     return ReadRegisterValueFromRegisterLocation (regloc, reg_info, value);
1368 }
1369
1370 bool
1371 RegisterContextLLDB::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &value)
1372 {
1373     if (!IsValid())
1374         return false;
1375
1376     const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
1377     UnwindLogMsgVerbose ("looking for register saved location for reg %d", lldb_regnum);
1378
1379     // If this is the 0th frame, hand this over to the live register context
1380     if (IsFrameZero ())
1381     {
1382         UnwindLogMsgVerbose ("passing along to the live register context for reg %d", lldb_regnum);
1383         return m_thread.GetRegisterContext()->WriteRegister (reg_info, value);
1384     }
1385
1386     lldb_private::UnwindLLDB::RegisterLocation regloc;
1387     // Find out where the NEXT frame saved THIS frame's register contents
1388     if (!m_parent_unwind.SearchForSavedLocationForRegister (lldb_regnum, regloc, m_frame_number - 1, false))
1389         return false;
1390
1391     return WriteRegisterValueToRegisterLocation (regloc, reg_info, value);
1392 }
1393
1394 // Don't need to implement this one
1395 bool
1396 RegisterContextLLDB::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
1397 {
1398     return false;
1399 }
1400
1401 // Don't need to implement this one
1402 bool
1403 RegisterContextLLDB::WriteAllRegisterValues (const lldb::DataBufferSP& data_sp)
1404 {
1405     return false;
1406 }
1407
1408 // Retrieve the pc value for THIS from
1409
1410 bool
1411 RegisterContextLLDB::GetCFA (addr_t& cfa)
1412 {
1413     if (!IsValid())
1414     {
1415         return false;
1416     }
1417     if (m_cfa == LLDB_INVALID_ADDRESS)
1418     {
1419         return false;
1420     }
1421     cfa = m_cfa;
1422     return true;
1423 }
1424
1425
1426 RegisterContextLLDB::SharedPtr
1427 RegisterContextLLDB::GetNextFrame () const
1428 {
1429     RegisterContextLLDB::SharedPtr regctx;
1430     if (m_frame_number == 0)
1431       return regctx;
1432     return m_parent_unwind.GetRegisterContextForFrameNum (m_frame_number - 1);
1433 }
1434
1435 RegisterContextLLDB::SharedPtr
1436 RegisterContextLLDB::GetPrevFrame () const
1437 {
1438     RegisterContextLLDB::SharedPtr regctx;
1439     return m_parent_unwind.GetRegisterContextForFrameNum (m_frame_number + 1);
1440 }
1441
1442 // Retrieve the address of the start of the function of THIS frame
1443
1444 bool
1445 RegisterContextLLDB::GetStartPC (addr_t& start_pc)
1446 {
1447     if (!IsValid())
1448         return false;
1449
1450     if (!m_start_pc.IsValid())
1451     {
1452         return ReadPC (start_pc);
1453     }
1454     start_pc = m_start_pc.GetLoadAddress (CalculateTarget().get());
1455     return true;
1456 }
1457
1458 // Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
1459
1460 bool
1461 RegisterContextLLDB::ReadPC (addr_t& pc)
1462 {
1463     if (!IsValid())
1464         return false;
1465
1466     if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc))
1467     {
1468         // A pc value of 0 or 1 is impossible in the middle of the stack -- it indicates the end of a stack walk.
1469         // On the currently executing frame (or such a frame interrupted asynchronously by sigtramp et al) this may
1470         // occur if code has jumped through a NULL pointer -- we want to be able to unwind past that frame to help
1471         // find the bug.
1472
1473         if (m_all_registers_available == false
1474             && (pc == 0 || pc == 1))
1475         {
1476             return false;
1477         }
1478         else
1479         {
1480             return true;
1481         }
1482     }
1483     else
1484     {
1485         return false;
1486     }
1487 }
1488
1489
1490 void
1491 RegisterContextLLDB::UnwindLogMsg (const char *fmt, ...)
1492 {
1493     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
1494     if (log)
1495     {
1496         va_list args;
1497         va_start (args, fmt);
1498
1499         char *logmsg;
1500         if (vasprintf (&logmsg, fmt, args) == -1 || logmsg == NULL)
1501         {
1502             if (logmsg)
1503                 free (logmsg);
1504             va_end (args);
1505             return;
1506         }
1507         va_end (args);
1508
1509         log->Printf ("%*sth%d/fr%u %s",
1510                       m_frame_number < 100 ? m_frame_number : 100, "", m_thread.GetIndexID(), m_frame_number,
1511                       logmsg);
1512         free (logmsg);
1513     }
1514 }
1515
1516 void
1517 RegisterContextLLDB::UnwindLogMsgVerbose (const char *fmt, ...)
1518 {
1519     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
1520     if (log && log->GetVerbose())
1521     {
1522         va_list args;
1523         va_start (args, fmt);
1524
1525         char *logmsg;
1526         if (vasprintf (&logmsg, fmt, args) == -1 || logmsg == NULL)
1527         {
1528             if (logmsg)
1529                 free (logmsg);
1530             va_end (args);
1531             return;
1532         }
1533         va_end (args);
1534
1535         log->Printf ("%*sth%d/fr%u %s",
1536                       m_frame_number < 100 ? m_frame_number : 100, "", m_thread.GetIndexID(), m_frame_number,
1537                       logmsg);
1538         free (logmsg);
1539     }
1540 }
1541