Add "Undeclared registers are marked as Undefined" to UnwindPlan, adopt it in arch default unwind plans

[jasonmolenda]

Summary

The ABI plugins can provide an architectural default unwind plan -- an UnwindPlan that will get you up the stack when you don't have any unwind information or function start addresses. The unwinder uses these arch default unwind plans in two cases: No information for this stack frame, or as a fast unwind plan to walk the stack quickly, when you're not retrieving additional registers. (the unwinder will often also try this as a "fallback" unwind plan when it thinks there might be more stack to discover, giving us the ever-awesome double-start() that we see on Darwin processes at the end of the backtrace, sigh)

The big important use of an arch default unwind plan is jitted code -- where lldb doesn't have any start addresses for the functions or unwind information. We can't detect where registers are spilled to the stack, but at least we can walk the stack.

However, when we have a stack 5 frames deep,

0 func1()
1 func2()
2 <no function, jitted code>
3 func3()
4 main()

If we navigate to frame 3 (func3) and say "p/x $r12", lldb will descend down the stack (ultimately to frame 0, func1) looking for a place where r12 was saved to stack before it was reused. If no saves/spills are found, the live r12 value in frame 0 is used.

The problem here is that we have no view into what happened in frame 2, the jitted code. It may have spilled r12 and modified the register. The rule in lldb is that we don't provide register values that are *possibly* modified -- the same reason why lldb won't pass caller-spilled aka volatile register values up the stack, e.g. rax on SysV x86_64, where a function is free to modify it without saving the old value. We cannot be sure that the value of these registers haven't been changed, so lldb will refuse to print $rax for frame 3 in this backtrace.

This patchset adds a new bool to UnwindPlan::Row which specifies that any register not explicitly defined should return as Undefined. This means that the saved-register-finder method should NOT continue down the stack looking for a saved value - we cannot know what happened in this stack frame, so it's not safe to continue searching and pass a register value up the stack.

The second use case of the arch default UnwindPlan is as a "fast Unwind Plan" when lldb only needs to retrieve frame pointer & pc values when doing a quick stack walk. In this case, when lldb is searching for a register in RegisterContextUnwind::SavedLocationForRegister, it first tries the fast unwind plan, and if the register isn't mentioned there, it tries to find a location in the Full unwind plan. I have one small modification here to treat an Undefined register in the *fast* unwind plan as meaning that we should look in the full unwind plan, instead of stopping here. The full unwind plan may have a real register save location; if it says the register is Undefined, then that will be used.

The big risk with this patch, obviously, is that I'm updating all of the architectural default unwind plans to mark undefined registers as unavailable. I worry that there's some target that is relying on architectural default unwind plans heavily and previously the frame 0 register values were passed up the stack ... and maybe it was right sometimes, but now lldb won't send them up any more. I'll need to watch the bots closely when this lands. I could have done the cowardly thing and only updated the SysV x86_64 and Darwin AArch64 ABI plugins, but this is a change I've been wanting to make for a while.

Testing this is something I don't have a good answer for. I could unit-test that the SysV x86_64 ABI's arch default UnwindPlan sets SetUnspecifiedRegistersAreUndefined, but that's not anything really useful. Until recently you could jit an expression that stopped at a breakpoint and you'd have a wonderfully unsymbolicated stack frame in the middle of the backtrace but some rascal like Raphael seems to have changed it so we have a Module for the jitted code with a function start address recently. :/ Short of a corefile or a test using a scripted process plugin (basically the same thing), I don't think I can simulate the use case here. On the up side, bugs show up real fast in the testsuite run as I found when I didn't originally remember how the fast unwind plan fallback needed to work when I wrote this patch. :)

[jasonmolenda]

I marked Pavel as the reviewer for this because he's maybe the most likely to have an opinion about this change; I don't mean to sign you up for review work if you don't have time right now. I don't know if the specifics of the patch are especially interesting, but the testability problem and the decision to update all of the arch default unwind plans seem the most notable/discussable to me.

[clayborg]

Makes sense, LGTM.

lldb/include/lldb/Symbol/UnwindPlan.h

public:
 
     bool SetRegisterLocationToUnspecified(uint32_t reg_num, bool can_replace);
 
     bool SetRegisterLocationToRegister(uint32_t reg_num, uint32_t other_reg_num,
                                        bool can_replace);
 
     bool SetRegisterLocationToSame(uint32_t reg_num, bool must_replace);
 
+    // When this UnspecifiedRegistersAreUndefined mode is
+    // set, any register that is not specified by this Row will
+    // be described as Undefined.
+    // This will prevent the unwinder from iterating down the
+    // stack looking for a spill location, or a live register value
+    // at frame 0.
+    // It would be used for an UnwindPlan row where we can't track
+    // spilled registers -- for instance a jitted stack frame where
+    // we have no unwind information or start address -- and registers
+    // MAY have been spilled and overwritten, so providing the
+    // spilled/live value from a newer frame may show an incorrect value.
+    void SetUnspecifiedRegistersAreUndefined(bool unspec_is_undef) {
+      m_unspecified_registers_are_undefined = unspec_is_undef;
+    }
+
+    bool GetUnspecifiedRegistersAreUndefined() {
+      return m_unspecified_registers_are_undefined;
+    }
+
     void Clear();
 
     void Dump(Stream &s, const UnwindPlan *unwind_plan, Thread *thread,
               lldb::addr_t base_addr) const;
 
   protected:
     typedef std::map<uint32_t, RegisterLocation> collection;
     lldb::addr_t m_offset; // Offset into the function for this row
 
     FAValue m_cfa_value;
     FAValue m_afa_value;
     collection m_register_locations;
+    bool m_unspecified_registers_are_undefined;
   }; // class Row
 
   typedef std::shared_ptr<Row> RowSP;
 
   UnwindPlan(lldb::RegisterKind reg_kind)
       : m_row_list(), m_plan_valid_address_range(), m_register_kind(reg_kind),
         m_return_addr_register(LLDB_INVALID_REGNUM), m_source_name(),
         m_plan_is_sourced_from_compiler(eLazyBoolCalculate),

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp

bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t fp_reg_num = arm64_dwarf::fp;
   uint32_t pc_reg_num = arm64_dwarf::pc;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 8;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp

bool ABISysV_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t fp_reg_num = arm64_dwarf::fp;
   uint32_t pc_reg_num = arm64_dwarf::pc;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 8;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

uint32_t fp_reg_num =
       dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
   uint32_t pc_reg_num = dwarf_pc;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 4;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

bool ABISysV_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t fp_reg_num = dwarf_r11;
   uint32_t pc_reg_num = dwarf_pc;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 4;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.cpp

bool ABISysV_hexagon::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.SetRegisterKind(eRegisterKindGeneric);
 
   uint32_t fp_reg_num = LLDB_REGNUM_GENERIC_FP;
   uint32_t sp_reg_num = LLDB_REGNUM_GENERIC_SP;
   uint32_t pc_reg_num = LLDB_REGNUM_GENERIC_PC;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
+  row->SetUnspecifiedRegistersAreUndefined(true);
   row->GetCFAValue().SetIsRegisterPlusOffset(LLDB_REGNUM_GENERIC_FP, 8);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, -8, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("hexagon default unwind plan");

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

 }
 
 bool ABISysV_mips::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.Clear();
   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
+  row->SetUnspecifiedRegistersAreUndefined(true);
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 
   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("mips default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

 }
 
 bool ABISysV_mips64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.Clear();
   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
+  row->SetUnspecifiedRegistersAreUndefined(true);
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 
   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("mips64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

bool ABISysV_ppc::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
 
   uint32_t sp_reg_num = dwarf_r1;
   uint32_t pc_reg_num = dwarf_lr;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int32_t ptr_size = 4;
+  row->SetUnspecifiedRegistersAreUndefined(true);
   row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
 
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("ppc default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

bool ABISysV_ppc64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   } else {
     sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64;
     pc_reg_num = ppc64_dwarf::dwarf_lr_ppc64;
     cr_reg_num = ppc64_dwarf::dwarf_cr_ppc64;
   }
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 8;
+  row->SetUnspecifiedRegistersAreUndefined(true);
   row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
 
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
   row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("ppc64 default unwind plan");

lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.cpp

bool ABIMacOSX_i386::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t sp_reg_num = dwarf_esp;
   uint32_t pc_reg_num = dwarf_eip;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 4;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("i386 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/source/Plugins/ABI/X86/ABISysV_i386.cpp

bool ABISysV_i386::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t sp_reg_num = dwarf_esp;
   uint32_t pc_reg_num = dwarf_eip;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 4;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("i386 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

bool ABISysV_x86_64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t sp_reg_num = dwarf_rsp;
   uint32_t pc_reg_num = dwarf_rip;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int32_t ptr_size = 8;
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("x86_64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

bool ABIWindows_x86_64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   uint32_t sp_reg_num = dwarf_rsp;
   uint32_t pc_reg_num = dwarf_rip;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int32_t ptr_size = 8;
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp, 2 * ptr_size);
   row->SetOffset(0);
+  row->SetUnspecifiedRegistersAreUndefined(true);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("x86_64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/source/Symbol/UnwindPlan.cpp

case isRaSearch:
     break;
   }
 }
 
 void UnwindPlan::Row::Clear() {
   m_cfa_value.SetUnspecified();
   m_afa_value.SetUnspecified();
   m_offset = 0;
+  m_unspecified_registers_are_undefined = false;
   m_register_locations.clear();
 }
 
 void UnwindPlan::Row::Dump(Stream &s, const UnwindPlan *unwind_plan,
                            Thread *thread, addr_t base_addr) const {
   if (base_addr != LLDB_INVALID_ADDRESS)
     s.Printf("0x%16.16" PRIx64 ": CFA=", base_addr + GetOffset());
   else
void UnwindPlan::Row::Dump(Stream &s, const UnwindPlan *unwind_plan,
   s.Printf(" => ");
   for (collection::const_iterator idx = m_register_locations.begin();
        idx != m_register_locations.end(); ++idx) {
     DumpRegisterName(s, unwind_plan, thread, idx->first);
     const bool verbose = false;
     idx->second.Dump(s, unwind_plan, this, thread, verbose);
     s.PutChar(' ');
   }
-  s.EOL();
 }
 
 UnwindPlan::Row::Row()
-    : m_offset(0), m_cfa_value(), m_afa_value(), m_register_locations() {}
+    : m_offset(0), m_cfa_value(), m_afa_value(), m_register_locations(),
+      m_unspecified_registers_are_undefined(false) {}
 
 bool UnwindPlan::Row::GetRegisterInfo(
     uint32_t reg_num,
     UnwindPlan::Row::RegisterLocation &register_location) const {
   collection::const_iterator pos = m_register_locations.find(reg_num);
   if (pos != m_register_locations.end()) {
     register_location = pos->second;
     return true;
   }
+  if (m_unspecified_registers_are_undefined) {
+    register_location.SetUndefined();
+    return true;
+  }
   return false;
 }
 
 void UnwindPlan::Row::RemoveRegisterInfo(uint32_t reg_num) {
   collection::const_iterator pos = m_register_locations.find(reg_num);
   if (pos != m_register_locations.end()) {
     m_register_locations.erase(pos);
   }
if (must_replace &&
     return false;
   RegisterLocation reg_loc;
   reg_loc.SetSame();
   m_register_locations[reg_num] = reg_loc;
   return true;
 }
 
 bool UnwindPlan::Row::operator==(const UnwindPlan::Row &rhs) const {
-  return m_offset == rhs.m_offset &&
-      m_cfa_value == rhs.m_cfa_value &&
+  return m_offset == rhs.m_offset && m_cfa_value == rhs.m_cfa_value &&
          m_afa_value == rhs.m_afa_value &&
+         m_unspecified_registers_are_undefined ==
+             rhs.m_unspecified_registers_are_undefined &&
          m_register_locations == rhs.m_register_locations;
 }
 
 void UnwindPlan::AppendRow(const UnwindPlan::RowSP &row_sp) {
   if (m_row_list.empty() ||
       m_row_list.back()->GetOffset() != row_sp->GetOffset())
     m_row_list.push_back(row_sp);
   else
     m_row_list.back() = row_sp;
m_plan_valid_address_range.Dump(&s, target_sp.get(),
                                     Address::DumpStyleSectionNameOffset);
     s.EOL();
   }
   collection::const_iterator pos, begin = m_row_list.begin(),
                                   end = m_row_list.end();
   for (pos = begin; pos != end; ++pos) {
     s.Printf("row[%u]: ", (uint32_t)std::distance(begin, pos));
     (*pos)->Dump(s, this, thread, base_addr);
+    s.Printf("\n");
   }
 }
 
 void UnwindPlan::SetSourceName(const char *source) {
   m_source_name = ConstString(source);
 }
 
 ConstString UnwindPlan::GetSourceName() const { return m_source_name; }

lldb/source/Target/RegisterContextUnwind.cpp

if (m_fast_unwind_plan_sp &&
     active_row =
         m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
     row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
     PropagateTrapHandlerFlagFromUnwindPlan(m_fast_unwind_plan_sp);
     if (active_row.get() && log) {
       StreamString active_row_strm;
       active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
                        m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
+      UnwindLogMsg("Using fast unwind plan '%s'",
+                   m_fast_unwind_plan_sp->GetSourceName().AsCString());
       UnwindLogMsg("active row: %s", active_row_strm.GetData());
     }
   } else {
     m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
     int valid_offset = -1;
     if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp, valid_offset)) {
       active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset);
       row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
       PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
       if (active_row.get() && log) {
         StreamString active_row_strm;
         active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
                          &m_thread,
                          m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
+        UnwindLogMsg("Using full unwind plan '%s'",
+                     m_full_unwind_plan_sp->GetSourceName().AsCString());
         UnwindLogMsg("active row: %s", active_row_strm.GetData());
       }
     }
   }
 
   if (!active_row.get()) {
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("could not find unwind row for this pc");
UnwindPlanSP RegisterContextUnwind::GetFastUnwindPlanForFrame() {
   // knowledge.
   if (m_frame_type == eTrapHandlerFrame || m_frame_type == eDebuggerFrame)
     return unwind_plan_sp;
 
   unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
       *m_thread.CalculateTarget(), m_thread);
   if (unwind_plan_sp) {
     if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
-      Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
-      if (log && log->GetVerbose()) {
-        if (m_fast_unwind_plan_sp)
-          UnwindLogMsgVerbose("frame, and has a fast UnwindPlan");
-        else
-          UnwindLogMsgVerbose("frame");
-      }
       m_frame_type = eNormalFrame;
       return unwind_plan_sp;
     } else {
       unwind_plan_sp.reset();
     }
   }
   return unwind_plan_sp;
 }

 
 // Answer the question: Where did THIS frame save the CALLER frame ("previous"
 // frame)'s register value?
 
 enum UnwindLLDB::RegisterSearchResult
 RegisterContextUnwind::SavedLocationForRegister(
     uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
   RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   // Have we already found this register location?
   if (!m_registers.empty()) {
     std::map<uint32_t,
              lldb_private::UnwindLLDB::RegisterLocation>::const_iterator
         iterator;
     iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB));
     if (iterator != m_registers.end()) {
if (m_fast_unwind_plan_sp) {
     unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
     if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
       UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind "
                    "reg numbering scheme",
                    regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
                    (int)unwindplan_registerkind);
       return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
+    // The architecture default unwind plan marks unknown registers as
+    // Undefined so that we don't forward them up the stack when a
+    // jitted stack frame may have overwritten them.  But when the
+    // arch default unwind plan is used as the Fast Unwind Plan, we
+    // need to recognize this & switch over to the Full Unwind Plan
+    // to see what unwind rule that (more knoweldgeable, probably)
+    // UnwindPlan has.  If the full UnwindPlan says the register 
+    // location is Undefined, then it really is.
     if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
-                                    unwindplan_regloc)) {
+                                    unwindplan_regloc) &&
+        !unwindplan_regloc.IsUndefined()) {
       UnwindLogMsg(
           "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
           regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
       have_unwindplan_regloc = true;
     }
   }
 
   if (!have_unwindplan_regloc) {
     // m_full_unwind_plan_sp being NULL means that we haven't tried to find a
     // full UnwindPlan yet
-    if (!m_full_unwind_plan_sp)
+    bool got_new_full_unwindplan = false;
+    if (!m_full_unwind_plan_sp) {
       m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
+      got_new_full_unwindplan = true;
+    }
 
     if (m_full_unwind_plan_sp) {
       RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
                                LLDB_REGNUM_GENERIC_PC);
 
       UnwindPlan::RowSP active_row =
           m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
       unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
 
+      if (got_new_full_unwindplan && active_row.get() && log) {
+        StreamString active_row_strm;
+        ExecutionContext exe_ctx(m_thread.shared_from_this());
+        active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
+                         &m_thread,
+                         m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
+        UnwindLogMsg("Using full unwind plan '%s'",
+                     m_full_unwind_plan_sp->GetSourceName().AsCString());
+        UnwindLogMsg("active row: %s", active_row_strm.GetData());
+      }
       RegisterNumber return_address_reg;
 
       // If we're fetching the saved pc and this UnwindPlan defines a
       // ReturnAddress register (e.g. lr on arm), look for the return address
       // register number in the UnwindPlan's row.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
               LLDB_INVALID_REGNUM) {