Support evaluation of DWARF expressions setting CFA

[labath]

Summary

This patch enables evaluation of DWARF expressions setting the CFA during stack unwinding.

This makes TestSigtrampUnwind "almost" pass on linux. I am not enabling the test yet since the
symbol name for the signal trampoline does not get resolved properly due to a different bug, but
apart from that, the backtrace is sane.

I am unsure how this change affects Mac. I think it makes the unwinder prefer the DWARF unwind
plan instead of some custom platform-dependant plan. However, it does not affect the end result

• the stack unwinding works as expected.

[labath]

Delete an obsolete comment.

[jasonmolenda]

This patch looks good to me, please commit. I don't anticipate any change in behavior on Mac systems.

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

case UnwindPlan::Row::CFAValue::isRegisterPlusOffset:
                 UnwindLogMsg ("CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64 ", offset is %d",
                               cfa_value,
                               cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
                               cfa_reg_contents, row->GetCFAValue().GetOffset());
                 return true;
             }
             break;
         }
-    // TODO: handle isDWARFExpression
+    case UnwindPlan::Row::CFAValue::isDWARFExpression:
+        {
+            ExecutionContext exe_ctx(m_thread.shared_from_this());
+            Process *process = exe_ctx.GetProcessPtr();
+            DataExtractor dwarfdata (row->GetCFAValue().GetDWARFExpressionBytes(),
+                                     row->GetCFAValue().GetDWARFExpressionLength(),
+                                     process->GetByteOrder(), process->GetAddressByteSize());
+            ModuleSP opcode_ctx;
+            DWARFExpression dwarfexpr (opcode_ctx, dwarfdata, 0, row->GetCFAValue().GetDWARFExpressionLength());
+            dwarfexpr.SetRegisterKind (row_register_kind);
+            Value result;
+            Error error;
+            if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
+            {
+                cfa_value = result.GetScalar().ULongLong();
+
+                UnwindLogMsg ("CFA value set by DWARF expression is 0x%" PRIx64, cfa_value);
+                return true;
+            }
+            UnwindLogMsg ("Failed to set CFA value via DWARF expression: %s", error.AsCString());
+            break;
+        }
     default:
         return false;
     }
     return false;
 }
 
 // Retrieve a general purpose register value for THIS frame, as saved by the NEXT frame, i.e. the frame that
 // this frame called.  e.g.

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                         row->GetCFAValue().SetIsRegisterPlusOffset (
                                 row->GetCFAValue().GetRegisterNumber(), op_offset);
                     }
                     break;
 
                 case DW_CFA_def_cfa_expression  : // 0xF    (CFA Definition Instruction)
                     {
                         size_t block_len = (size_t)m_cfi_data.GetULEB128(&offset);
-                        offset += (uint32_t)block_len;
+                        const uint8_t *block_data =
+                            static_cast<const uint8_t *>(m_cfi_data.GetData(&offset, block_len));
+                        row->GetCFAValue().SetIsDWARFExpression(block_data, block_len);
                     }
                     break;
 
                 case DW_CFA_expression          : // 0x10
                     {
                         // Takes two operands: an unsigned LEB128 value representing
                         // a register number, and a DW_FORM_block value representing a DWARF
                         // expression. The required action is to change the rule for the

lldb/trunk/source/Symbol/UnwindPlan.cpp

if (GetRowCount() == 0)
                              m_source_name.GetCString());
             }
         }
         return false;
     }
 
     // If the 0th Row of unwind instructions is missing, or if it doesn't provide
     // a register to use to find the Canonical Frame Address, this is not a valid UnwindPlan.
-    // CFA set by a DWARF expression is not currently supported, so ignore that as well.
     if (GetRowAtIndex(0).get() == nullptr ||
-            GetRowAtIndex(0)->GetCFAValue().GetValueType() == Row::CFAValue::unspecified ||
-            GetRowAtIndex(0)->GetCFAValue().GetValueType() == Row::CFAValue::isDWARFExpression)
+            GetRowAtIndex(0)->GetCFAValue().GetValueType() == Row::CFAValue::unspecified)
     {
         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
         if (log)
         {
             StreamString s;
             if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset))
             {
                 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s' at address %s",