When unwinding out of a trap handler, fetch the saved pc even if there's a return address register defined

[jasonmolenda]

Summary

On targets with a return address register (e.g. $lr on arm), when the unwinder is asked to fetch the caller's pc, we rewrite that to fetch the return address value.

However, when we're in a trap handler -- either from an interrupt or an async signal -- we will have a full register context for the frame that was interrupted/trapped. The unwinder correctly allows you to fetch volatile registers when you're above a trap handler. But we are still rewriting the "fetch the pc" request when the trap handler is asked to find the caller's saved pc. This is incorrect, and results in lldb showing the wrong function that was interrupted/faulted.

lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

if (pc == 0 || pc == 0x1) {
     }
   }
 
   const bool allow_section_end = true;
   m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
 
   // If we don't have a Module for some reason, we're not going to find
   // symbol/function information - just stick in some reasonable defaults and
-  // hope we can unwind past this frame.
+  // hope we can unwind past this frame.  If we're above a trap handler,
+  // we may be at a bogus address because we jumped through a bogus function
+  // pointer and trapped, so don't force the arch default unwind plan in that 
+  // case.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
-  if (!m_current_pc.IsValid() || !pc_module_sp) {
+  if ((!m_current_pc.IsValid() || !pc_module_sp) &&
+      above_trap_handler == false) {
     UnwindLogMsg("using architectural default unwind method");
 
     // Test the pc value to see if we know it's in an unmapped/non-executable
     // region of memory.
     uint32_t permissions;
     if (process->GetLoadAddressPermissions(pc, permissions) &&
         (permissions & ePermissionsExecutable) == 0) {
       // If this is the second frame off the stack, we may have unwound the
if (m_full_unwind_plan_sp) {
           m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
       unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
 
       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 this is a trap handler frame, we have access to the complete
+      // register context when the interrupt/async signal was received, so
+      // we need to fetch the actual saved $pc value.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
-              LLDB_INVALID_REGNUM) {
+              LLDB_INVALID_REGNUM &&
+          m_frame_type != eTrapHandlerFrame) {
 
         return_address_reg.init(
             m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
             m_full_unwind_plan_sp->GetReturnAddressRegister());
         regnum = return_address_reg;
         UnwindLogMsg("requested caller's saved PC but this UnwindPlan uses a "
                      "RA reg; getting %s (%d) instead",
                      return_address_reg.GetName(),