Return an error when the CFA resolves to no known register, instead of segfaulting

[jasonmolenda]

Summary

I'm working on a bug report where lldb crashes while trying to read the register that is used to calculate the canonical frame address for the first frame in a stack trace. I haven't figured out how they're getting in this state yet, but I want to add a check for a failure to find a register in this case, and declare the stack frame as invalid to handle the error. I also added an assert so we can catch it early in debug builds if it ever comes up here.

I think returning no valid stack frame for this thread is going to be a better failure mode than having the debugger crash out from under them, ending the debug session. It's still a pretty bad failure, but hopefully we can collect some logging with this if it comes up again.

[bulbazord]

LGTM. I wonder if there's a good way to exercise this with a test? Like maybe we can create some bogus unwind information and see if LLDB falls over when consuming it?

[jasonmolenda]

In D143232#4101396, @bulbazord wrote:

LGTM. I wonder if there's a good way to exercise this with a test? Like maybe we can create some bogus unwind information and see if LLDB falls over when consuming it?

I'm not sure how we could do that tbh - the currently executing frame uses an unwind plan sourced from the assembly instructions, and I can't construct assembly language that lldb would parse as using an invalid register number to calculate the canonical frame address. (I genuinely have no idea how we're hitting this codepath; it should not be possible.)

lldb/source/Target/RegisterContextUnwind.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/VASPrintf.h"
 #include "lldb/lldb-private.h"
+
+#include <cassert>
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
   if (sym_ctx.symbol)
     return sym_ctx.symbol->GetName();
if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
     if (!cfa_status) {
       UnwindLogMsg("could not read CFA value for first frame.");
       m_frame_type = eNotAValidFrame;
       return;
     }
   } else
     ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
 
+  if (m_cfa == LLDB_INVALID_ADDRESS && m_afa == LLDB_INVALID_ADDRESS) {
+    UnwindLogMsg(
+        "could not read CFA or AFA values for first frame, not valid.");
+    m_frame_type = eNotAValidFrame;
+    return;
+  }
+
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
                " afa is 0x%" PRIx64 " using %s UnwindPlan",
                (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
                (uint64_t)m_cfa,
                (uint64_t)m_afa,
                m_full_unwind_plan_sp->GetSourceName().GetCString());
 }
 
bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
   if (register_kind == eRegisterKindLLDB) {
     lldb_regnum = regnum;
   } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
                  register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
     return false;
   }
 
   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
+  assert(reg_info);
+  if (!reg_info) {
+    UnwindLogMsg(
+        "Could not find RegisterInfo definition for lldb register number %d",
+        lldb_regnum);
+    return false;
+  }
+
   RegisterValue reg_value;
   // if this is frame 0 (currently executing frame), get the requested reg
   // contents from the actual thread registers
   if (IsFrameZero()) {
     if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
       value = reg_value.GetAsUInt64();
       return true;
     }