UnwindPlan::Row refactor -- add support for CFA set by a DWARF expression

[labath]

Summary

This change refactors UnwindPlan::Row to be able to store the fact that the CFA is value is set
by evaluating a dwarf expression (DW_CFA_def_cfa_expression). This is achieved by creating a new
class CFAValue and moving all CFA setting/getting code there. Note that code using the new
CFAValue::isDWARFExpression is not yet present and will be added in a follow-up patch. Therefore,
this patch should not change the functionality in any way.

[clayborg]

I will defer to Jason on this.

[jasonmolenda]

This looks fine to me. I don't have a problem with the CFAValue::IncOffset() method but it would be more in keeping with the typical lldb style if this class still had a SetOffset() method. It's more a consistency thing than one being better than the other - if I see GetOffset(), I'm going to assume there is also a SetOffset(). I'm fine with keeping IncOffset() - in some code sequences it will be more natural than SetOffset. And you've made the code a little less clear in places where that is the natural way to express what is being done. Like in UnwindAssembly-x86.cpp we went from

row->SetCFAOffset (current_sp_bytes_offset_from_cfa);

to

row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_sp_regnum,
        current_sp_bytes_offset_from_cfa);

which obscures what is really being done IMO. I'd prefer the places where you changed SetOffset to SetIsRegisterPlusOffset remain SetOffset.

include/lldb/Symbol/UnwindPlan.h

244 ↗

(On Diff #20290)

Very minor comment but I don't know if RestoreType is the best nomenclature in this case. I don't have a better suggestion right now. In an unwind scenario, I think of "restore" as meaning "retrieving the value of a register that was saved by a callee". Maybe I'll think up something better later. CFACalculateType would be closer, but that sounds horrible.

316 ↗

(On Diff #20290)

I was worried about the ownership of the opcode bytes in SetIsDWARFExpression but I guess the assumption is that this will come from the DWARF for the Module and since the UnwindPlans are also owned by the Module, they'll have the same lifetime. This should be fine.

[labath]

The reason I avoided the SetOffset() function was that carried the assumption that the only way to set the CFA value was reg+offset, which I think was true at some point (and I think some of the code still assumes that, like the Row::Dump part which I removed), but it wasn't true even before this patch --- it could be set as [reg], in which case the offset was ignored. If we allow setting the offset separately, then the question is what should be done when the current value type is not "isRegisterPlusOffset":

• set the type to "isRegisterPlusOffset", but leave the register undefined?
• set the type to "isRegisterPlusOffset", and set the register to some default value?
• ignore the SetOffset() command?
• return an error?

IncOffset is slightly better I think because it is more obvious that if you want to increment something, it has to be valid in the first place. I agree that the SetIsRegisterPlusOffset makes things a bit cumbersome, but actually most of those places could be naturally changed to use IncOffset instead. And we have a precedent for now having a SetOffset function: Row::RegisterLocation provides a GetOffset method, but is only settable via SetAtCFAPlusOffset and the like.

What do you think?

include/lldb/Symbol/UnwindPlan.h

244 ↗

(On Diff #20290)

How about just ValueType, given that the class is called CFAValue , and the getter is GetValueType()?

316 ↗

(On Diff #20290)

I modeled this class after Row::RegisterLocation, where they do the same thing, basically. So I think it should be ok...

[labath]

Renamed CFAValue::RestoreType -> ValueType

[labath]

Forgot to add break statements to switch. I blame Go.

[jasonmolenda]

Yeah, I can see what you're talking about with CFAValue::SetOffset() assuming the type of the CFA value but for instance in UnwindAssembly-x86, when it knows that the CFA is set in terms of rsp and the stack pointer value changes, it already knows that the CFA value type is IsRegisterPlusOffset - it is safe to simply call SetOffset() here.

In the case of UnwindAssembly-x86, it needs to track the stack pointer as it is modified throughout the lifetime of the function. When a register is saved on the stack, it records where that register was saved. It would be possible for it to track all of this in the CFAValue class - calling GetOffset() instead of using a local, calling IncrementOffset() whenever the stack value is moved down. There'd need to be a matching DecrementOffset() to match, of course. But I think it's more natural (to me, anyway) to have a local var tracking these changes and calling SetOffset() whenever needed.

I don't think the CFAValue class needs to dictate how the users behave - I'm fine with having methods to adjust the value - but I'd rather classes like UnwindAssembly-x86 continue to call SetOffset(). We could make it return a bool if the operation was invalid, but IncrementOffset() would have the same issues for that matter. I don't think it's worth worrying about.

Thanks for making the adjustment to the patch.

[labath]

I have added a SetOffset function and refactored UnwindAssembly-x86 to use it. Submitting.

lldb/trunk/include/lldb/Symbol/UnwindPlan.h

public:
                 // For m_type == atDWARFExpression or m_type == isDWARFExpression
                 struct {
                     const uint8_t *opcodes;
                     uint16_t length;
                 } expr;
             } m_location;
         };
     
+        class CFAValue
+        {
         public:
-        Row ();
-    
-        Row (const UnwindPlan::Row& rhs) : 
-            m_offset             (rhs.m_offset),
-            m_cfa_type           (rhs.m_cfa_type),
-            m_cfa_reg_num        (rhs.m_cfa_reg_num),
-            m_cfa_offset         (rhs.m_cfa_offset),
-            m_register_locations (rhs.m_register_locations)
+            enum ValueType
+            {
+                unspecified,                  // not specified
+                isRegisterPlusOffset,         // CFA = register + offset
+                isRegisterDereferenced,       // CFA = [reg]
+                isDWARFExpression             // CFA = eval(dwarf_expr)
+            };
+
+            CFAValue() :
+                m_type(unspecified),
+                m_value()
             {
             }
 
             bool
-        operator == (const Row &rhs) const;
+            operator == (const CFAValue& rhs) const;
 
             bool
-        GetRegisterInfo (uint32_t reg_num, RegisterLocation& register_location) const;
-    
+            operator != (const CFAValue &rhs) const
+            {
+                return !(*this == rhs);
+            }
             void
-        SetRegisterInfo (uint32_t reg_num, const RegisterLocation register_location);
+            SetUnspecified()
+            {
+                m_type = unspecified;
+            }
+
+            bool
+            IsUnspecified () const
+            {
+                return m_type == unspecified;
+            }
+
+            bool
+            IsRegisterPlusOffset () const
+            {
+                return m_type == isRegisterPlusOffset;
+            }
 
             void
-        RemoveRegisterInfo (uint32_t reg_num);
+            SetIsRegisterPlusOffset (uint32_t reg_num, int32_t offset)
+            {
+                m_type = isRegisterPlusOffset;
+                m_value.reg.reg_num = reg_num;
+                m_value.reg.offset = offset;
+            }
 
-        lldb::addr_t
-        GetOffset() const
+            bool
+            IsRegisterDereferenced () const
             {
-            return m_offset;
+                return m_type == isRegisterDereferenced;
             }
 
             void
-        SetOffset(lldb::addr_t offset)
+            SetIsRegisterDereferenced (uint32_t reg_num)
             {
-            m_offset = offset;
+                m_type = isRegisterDereferenced;
+                m_value.reg.reg_num = reg_num;
+            }
+
+            bool
+            IsDWARFExpression () const
+            {
+                return m_type == isDWARFExpression;
             }
 
             void
-        SlideOffset(lldb::addr_t offset)
+            SetIsDWARFExpression (const uint8_t *opcodes, uint32_t len)
             {
-            m_offset += offset;
+                m_type = isDWARFExpression;
+                m_value.expr.opcodes = opcodes;
+                m_value.expr.length = len;
             }
 
-        // How we can reconstruct the CFA address for this stack frame, at this location
-        enum CFAType
+            uint32_t
+            GetRegisterNumber () const
             {
-            CFAIsRegisterPlusOffset,   // the CFA value in a register plus (or minus) an offset
-            CFAIsRegisterDereferenced  // the address in a register is dereferenced to get CFA value
-        };
+                if (m_type == isRegisterDereferenced || m_type == isRegisterPlusOffset)
+                    return m_value.reg.reg_num;
+                return LLDB_INVALID_REGNUM;
+            }
 
-        CFAType
-        GetCFAType () const
+            ValueType
+            GetValueType () const
             {
-            return m_cfa_type;
+                return m_type;
+            }
+
+            int32_t
+            GetOffset () const
+            {
+                if (m_type == isRegisterPlusOffset)
+                    return m_value.reg.offset;
+                return 0;
+            }
+
+            void IncOffset (int32_t delta)
+            {
+                if (m_type == isRegisterPlusOffset)
+                    m_value.reg.offset += delta;
+            }
+
+            void SetOffset (int32_t offset)
+            {
+                if (m_type == isRegisterPlusOffset)
+                    m_value.reg.offset = offset;
             }
 
             void
-        SetCFAType (CFAType cfa_type)
+            GetDWARFExpr (const uint8_t **opcodes, uint16_t& len) const
+            {
+                if (m_type == isDWARFExpression)
                 {
-            m_cfa_type = cfa_type;
+                    *opcodes = m_value.expr.opcodes;
+                    len = m_value.expr.length;
+                }
+                else
+                {
+                    *opcodes = NULL;
+                    len = 0;
+                }
             }
 
-        // If GetCFAType() is CFAIsRegisterPlusOffset, add GetCFAOffset to the reg value to get CFA value
-        // If GetCFAType() is CFAIsRegisterDereferenced, dereference the addr in the reg to get CFA value
-        uint32_t
-        GetCFARegister () const
+            const uint8_t *
+            GetDWARFExpressionBytes ()
+            {
+                if (m_type == isDWARFExpression)
+                    return m_value.expr.opcodes;
+                return NULL;
+            }
+
+            int
+            GetDWARFExpressionLength ()
             {
-            return m_cfa_reg_num;
+                if (m_type == isDWARFExpression)
+                    return m_value.expr.length;
+                return 0;
             }
-        
             void
-        SetCFARegister (uint32_t reg_num);
+            Dump (Stream &s,
+                  const UnwindPlan* unwind_plan,
+                  Thread* thread) const;
 
-        // This should not be used when GetCFAType() is CFAIsRegisterDereferenced; will return 0 in that case.
-        int32_t
-        GetCFAOffset () const
+        private:
+            ValueType m_type;            // How do we compute CFA value?
+            union
+            {
+                struct {
+                    // For m_type == isRegisterPlusOffset or m_type == isRegisterDereferenced
+                    uint32_t reg_num; // The register number
+                    // For m_type == isRegisterPlusOffset
+                    int32_t offset;
+                } reg;
+                // For m_type == isDWARFExpression
+                struct {
+                    const uint8_t *opcodes;
+                    uint16_t length;
+                } expr;
+            } m_value;
+        }; // class CFAValue
+
+    public:
+        Row ();
+
+        Row (const UnwindPlan::Row& rhs) = default;
+
+        bool
+        operator == (const Row &rhs) const;
+
+        bool
+        GetRegisterInfo (uint32_t reg_num, RegisterLocation& register_location) const;
+    
+        void
+        SetRegisterInfo (uint32_t reg_num, const RegisterLocation register_location);
+
+        void
+        RemoveRegisterInfo (uint32_t reg_num);
+
+        lldb::addr_t
+        GetOffset() const
         {
-            return m_cfa_offset;
+            return m_offset;
         }
 
         void
-        SetCFAOffset (int32_t offset)
+        SetOffset(lldb::addr_t offset)
         {
-            m_cfa_offset = offset;
+            m_offset = offset;
+        }
+
+        void
+        SlideOffset(lldb::addr_t offset)
+        {
+            m_offset += offset;
+        }
+
+        CFAValue& GetCFAValue()
+        {
+            return m_cfa_value;
         }
 
         bool
         SetRegisterLocationToAtCFAPlusOffset (uint32_t reg_num, 
                                               int32_t offset, 
                                               bool can_replace);
 
         bool
public:
 
         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
 
-        CFAType m_cfa_type;
-
-        // If m_cfa_type == CFAIsRegisterPlusOffset, the CFA address is computed as m_cfa_reg_num + m_cfa_offset
-        // If m_cfa_type == CFAIsRegisterDereferenced, the CFA address is computed as *(m_cfa_reg_num) - i.e. the
-        // address in m_cfa_reg_num is dereferenced and the pointer value read is the CFA addr.
-        uint32_t m_cfa_reg_num;     // The Call Frame Address register number
-        int32_t  m_cfa_offset;      // The offset from the CFA for this row
-
+        CFAValue m_cfa_value;
         collection m_register_locations;
     }; // class Row
 
 public:
 
     typedef std::shared_ptr<Row> RowSP;
 
     UnwindPlan (lldb::RegisterKind reg_kind) : 
GetReturnAddressRegister (void)
         return m_return_addr_register;
     }
 
     uint32_t
     GetInitialCFARegister () const
     {
         if (m_row_list.empty())
             return LLDB_INVALID_REGNUM;
-        return m_row_list.front()->GetCFARegister();
+        return m_row_list.front()->GetCFAValue().GetRegisterNumber();
     }
 
     // This UnwindPlan may not be valid at every address of the function span.  
     // For instance, a FastUnwindPlan will not be valid at the prologue setup 
     // instructions - only in the body of the function.
     void
     SetPlanValidAddressRange (const AddressRange& range);
 

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

ABIMacOSX_arm::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
 
     uint32_t lr_reg_num = dwarf_lr;
     uint32_t sp_reg_num = dwarf_sp;
     uint32_t pc_reg_num = dwarf_pc;
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
     
     // Our Call Frame Address is the stack pointer value
-    row->SetCFARegister (sp_reg_num);
+    row->GetCFAValue().SetIsRegisterPlusOffset (sp_reg_num, 0);
     
     // The previous PC is in the LR
     row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
     unwind_plan.AppendRow (row);
     
     // All other registers are the same.
     
     unwind_plan.SetSourceName ("arm at-func-entry default");
ABIMacOSX_arm::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     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->SetCFARegister (fp_reg_num);
-    row->SetCFAOffset (2 * ptr_size);
+    row->GetCFAValue().SetIsRegisterPlusOffset (fp_reg_num, 2 * ptr_size);
     row->SetOffset (0);
     
     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);

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

ABIMacOSX_arm64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
     
     uint32_t lr_reg_num = arm64_dwarf::lr;
     uint32_t sp_reg_num = arm64_dwarf::sp;
     uint32_t pc_reg_num = arm64_dwarf::pc;
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
     
     // Our previous Call Frame Address is the stack pointer
-    row->SetCFARegister (sp_reg_num);
+    row->GetCFAValue().SetIsRegisterPlusOffset (sp_reg_num, 0);
     
     // Our previous PC is in the LR
     row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
     
     unwind_plan.AppendRow (row);
     
     // All other registers are the same.
     
ABIMacOSX_arm64::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
     
     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->SetCFARegister (fp_reg_num);
-    row->SetCFAOffset (2 * ptr_size);
+    row->GetCFAValue().SetIsRegisterPlusOffset (fp_reg_num, 2 * ptr_size);
     row->SetOffset (0);
     
     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);

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

 {
     unwind_plan.Clear();
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     uint32_t sp_reg_num = dwarf_esp;
     uint32_t pc_reg_num = dwarf_eip;
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
-    row->SetCFARegister (sp_reg_num);
-    row->SetCFAOffset (4);
+    row->GetCFAValue().SetIsRegisterPlusOffset (sp_reg_num, 4);
     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, false);
     row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
     unwind_plan.AppendRow (row);
     unwind_plan.SetSourceName ("i386 at-func-entry default");
     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
     return true;
 }
 
ABIMacOSX_i386::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
 
     uint32_t fp_reg_num = dwarf_ebp;
     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->SetCFARegister (fp_reg_num);
-    row->SetCFAOffset (2 * ptr_size);
+    row->GetCFAValue().SetIsRegisterPlusOffset (fp_reg_num, 2 * ptr_size);
     row->SetOffset (0);
     
     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");

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 {
     unwind_plan.Clear();
     unwind_plan.SetRegisterKind(eRegisterKindGeneric);
     unwind_plan.SetReturnAddressRegister(LLDB_REGNUM_GENERIC_RA);
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     // Our Call Frame Address is the stack pointer value
-    row->SetCFARegister(LLDB_REGNUM_GENERIC_SP);
-    row->SetCFAOffset(4);
+    row->GetCFAValue().SetIsRegisterPlusOffset (LLDB_REGNUM_GENERIC_SP, 4);
     row->SetOffset(0);
 
     // The previous PC is in the LR
     row->SetRegisterLocationToRegister(LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_RA, true);
     unwind_plan.AppendRow(row);
     
     unwind_plan.SetSourceName("hexagon at-func-entry default");
     unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
     return true;
 }
 
 bool
 ABISysV_hexagon::CreateDefaultUnwindPlan ( UnwindPlan &unwind_plan )
 {
     unwind_plan.Clear();
     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->SetCFARegister(LLDB_REGNUM_GENERIC_FP);
-    row->SetCFAOffset(8);
+    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");
     unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

ABISysV_ppc::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
 
     uint32_t lr_reg_num = gcc_dwarf_lr;
     uint32_t sp_reg_num = gcc_dwarf_r1;
     uint32_t pc_reg_num = gcc_dwarf_pc;
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     // Our Call Frame Address is the stack pointer value
-    row->SetCFARegister (sp_reg_num);
+    row->GetCFAValue().SetIsRegisterPlusOffset (sp_reg_num, 0);
 
     // The previous PC is in the LR
     row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
     unwind_plan.AppendRow (row);
 
     // All other registers are the same.
 
     unwind_plan.SetSourceName ("ppc at-func-entry default");
ABISysV_ppc::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     uint32_t sp_reg_num = gcc_dwarf_r1;
     uint32_t pc_reg_num = gcc_dwarf_lr;
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     const int32_t ptr_size = 4;
-    row->SetCFARegister (sp_reg_num);
-    row->SetCFAType(lldb_private::UnwindPlan::Row::CFAIsRegisterDereferenced);
+    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);
     unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolNo);

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

ABISysV_ppc64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
 
     uint32_t lr_reg_num = gcc_dwarf_lr;
     uint32_t sp_reg_num = gcc_dwarf_r1;
     uint32_t pc_reg_num = gcc_dwarf_pc;
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     // Our Call Frame Address is the stack pointer value
-    row->SetCFARegister (sp_reg_num);
+    row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
 
     // The previous PC is in the LR
     row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
     unwind_plan.AppendRow (row);
 
     // All other registers are the same.
 
     unwind_plan.SetSourceName ("ppc64 at-func-entry default");
ABISysV_ppc64::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     uint32_t sp_reg_num = gcc_dwarf_r1;
     uint32_t pc_reg_num = gcc_dwarf_lr;
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     const int32_t ptr_size = 8;
-    row->SetCFARegister (sp_reg_num);
-    row->SetCFAType(lldb_private::UnwindPlan::Row::CFAIsRegisterDereferenced);
+    row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
 
     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
     row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
     row->SetRegisterLocationToAtCFAPlusOffset(gcc_dwarf_cr, ptr_size, true);
 
     unwind_plan.AppendRow (row);
     unwind_plan.SetSourceName ("ppc64 default unwind plan");
     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

 {
     unwind_plan.Clear();
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
     
     uint32_t sp_reg_num = gcc_dwarf_rsp;
     uint32_t pc_reg_num = gcc_dwarf_rip;
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
-    row->SetCFARegister (sp_reg_num);
-    row->SetCFAOffset (8);
+    row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
     row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
     unwind_plan.AppendRow (row);
     unwind_plan.SetSourceName ("x86_64 at-func-entry default");
     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
     return true;
 }
 
ABISysV_x86_64::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
 
     uint32_t fp_reg_num = gcc_dwarf_rbp;
     uint32_t sp_reg_num = gcc_dwarf_rsp;
     uint32_t pc_reg_num = gcc_dwarf_rip;
     
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     const int32_t ptr_size = 8;
-    row->SetCFARegister (gcc_dwarf_rbp);
-    row->SetCFAOffset (2 * ptr_size);
+    row->GetCFAValue().SetIsRegisterPlusOffset(gcc_dwarf_rbp, 2 * ptr_size);
     row->SetOffset (0);
     
     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");

lldb/trunk/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

 EmulateInstructionARM::CreateFunctionEntryUnwind (UnwindPlan &unwind_plan)
 {
     unwind_plan.Clear();
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
 
     // Our previous Call Frame Address is the stack pointer
-    row->SetCFARegister (dwarf_sp);
+    row->GetCFAValue().SetIsRegisterPlusOffset (dwarf_sp, 0);
     
     // Our previous PC is in the LR
     row->SetRegisterLocationToRegister(dwarf_pc, dwarf_lr, true);
     unwind_plan.AppendRow (row);
 
     // All other registers are the same.
     
     unwind_plan.SetSourceName ("EmulateInstructionARM");
     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
     unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolYes);
     return true;
 }

lldb/trunk/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

 {
     unwind_plan.Clear();
     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 
     UnwindPlan::RowSP row(new UnwindPlan::Row);
     const bool can_replace = false;
 
     // Our previous Call Frame Address is the stack pointer
-    row->SetCFARegister (arm64_dwarf::sp);
+    row->GetCFAValue().SetIsRegisterPlusOffset(arm64_dwarf::sp, 0);
     
     // Our previous PC is in the LR
     row->SetRegisterLocationToRegister(arm64_dwarf::pc, arm64_dwarf::lr, can_replace);
 
     unwind_plan.AppendRow (row);
     
     // All other registers are the same.
     

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

RegisterContextLLDB::InitializeNonZerothFrame()
     {
         m_frame_type = eNotAValidFrame;
         UnwindLogMsg ("could not find unwind row for this pc");
         return;
     }
 
     if (!ReadCFAValueForRow (row_register_kind, active_row, m_cfa))
     {
-        UnwindLogMsg ("failed to get cfa reg %d/%d", row_register_kind, active_row->GetCFARegister());
+        UnwindLogMsg ("failed to get cfa");
         m_frame_type = eNotAValidFrame;
         return;
     }
 
     UnwindLogMsg ("m_cfa = 0x%" PRIx64, m_cfa);
 
     if (CheckIfLoopingStack ())
     {
RegisterContextLLDB::TryFallbackUnwindPlan ()
     addr_t old_cfa = m_cfa;
 
     m_registers.clear();
 
     m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
 
     UnwindPlan::RowSP active_row = m_fallback_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
     
-    if (active_row && active_row->GetCFARegister() != LLDB_INVALID_REGNUM)
+    if (active_row && active_row->GetCFAValue().GetValueType() != UnwindPlan::Row::CFAValue::unspecified)
     {
         addr_t new_cfa;
         if (!ReadCFAValueForRow (m_fallback_unwind_plan_sp->GetRegisterKind(), active_row, new_cfa)
             || new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS)
         {
             UnwindLogMsg ("failed to get cfa with fallback unwindplan");
             m_fallback_unwind_plan_sp.reset();
             m_full_unwind_plan_sp = original_full_unwind_plan_sp;
RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan ()
     if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get()
         || m_full_unwind_plan_sp->GetSourceName() == m_fallback_unwind_plan_sp->GetSourceName())
     {
         return false;
     }
 
     UnwindPlan::RowSP active_row = m_fallback_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
     
-    if (active_row && active_row->GetCFARegister() != LLDB_INVALID_REGNUM)
+    if (active_row && active_row->GetCFAValue().GetValueType() != UnwindPlan::Row::CFAValue::unspecified)
     {
         addr_t new_cfa;
         if (!ReadCFAValueForRow (m_fallback_unwind_plan_sp->GetRegisterKind(), active_row, new_cfa)
             || new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS)
         {
             UnwindLogMsg ("failed to get cfa with fallback unwindplan");
             m_fallback_unwind_plan_sp.reset();
             return false;
RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan ()
     return false;
 }
 
 bool
 RegisterContextLLDB::ReadCFAValueForRow (lldb::RegisterKind row_register_kind,
                                          const UnwindPlan::RowSP &row,
                                          addr_t &cfa_value)
 {
-    RegisterNumber cfa_reg (m_thread, row_register_kind, row->GetCFARegister());
     RegisterValue reg_value;
 
     cfa_value = LLDB_INVALID_ADDRESS;
     addr_t cfa_reg_contents;
 
-    if (ReadGPRValue (cfa_reg, cfa_reg_contents))
+    switch (row->GetCFAValue().GetValueType())
+    {
+    case UnwindPlan::Row::CFAValue::isRegisterDereferenced:
         {
-        if (row->GetCFAType() == UnwindPlan::Row::CFAIsRegisterDereferenced)
+            RegisterNumber cfa_reg (m_thread, row_register_kind, row->GetCFAValue().GetRegisterNumber());
+            if (ReadGPRValue (cfa_reg, cfa_reg_contents))
             {
                 const RegisterInfo *reg_info = GetRegisterInfoAtIndex (cfa_reg.GetAsKind (eRegisterKindLLDB));
                 RegisterValue reg_value;
                 if (reg_info)
                 {
                     Error error = ReadRegisterValueFromMemory(reg_info,
                                                               cfa_reg_contents,
                                                               reg_info->byte_size,
                                                               reg_value);
                     if (error.Success ())
                     {
                         cfa_value = reg_value.GetAsUInt64();
                         UnwindLogMsg ("CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64 ", CFA value is 0x%" PRIx64,
                                       cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
                                       cfa_reg_contents, cfa_value);
                         return true;
                     }
                     else
                     {
                         UnwindLogMsg ("Tried to deref reg %s (%d) [0x%" PRIx64 "] but memory read failed.",
                                       cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
                                       cfa_reg_contents);
                     }
                 }
             }
-        else
+            break;
+        }
+    case UnwindPlan::Row::CFAValue::isRegisterPlusOffset:
+        {
+            RegisterNumber cfa_reg (m_thread, row_register_kind, row->GetCFAValue().GetRegisterNumber());
+            if (ReadGPRValue (cfa_reg, cfa_reg_contents))
             {
                 if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 || cfa_reg_contents == 1)
                 {
                     UnwindLogMsg ("Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
                                   cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
                                   cfa_reg_contents);
                     cfa_reg_contents = LLDB_INVALID_ADDRESS;
                     return false;
                 }
-            cfa_value = cfa_reg_contents + row->GetCFAOffset ();
+                cfa_value = cfa_reg_contents + row->GetCFAValue().GetOffset();
                 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->GetCFAOffset ());
+                              cfa_value,
+                              cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
+                              cfa_reg_contents, row->GetCFAValue().GetOffset());
                 return true;
             }
+            break;
+        }
+    // TODO: handle isDWARFExpression
+    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.
 //
 //  foo () { }

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

//            }
 
         case EmulateInstruction::eContextSetFramePointer:
             if (!m_fp_is_cfa)
             {
                 m_fp_is_cfa = true;
                 m_cfa_reg_info = *reg_info;
                 const uint32_t cfa_reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
                 assert (cfa_reg_num != LLDB_INVALID_REGNUM);
-                m_curr_row->SetCFARegister(cfa_reg_num);
-                m_curr_row->SetCFAOffset(m_initial_sp - reg_value.GetAsUInt64());
+                m_curr_row->GetCFAValue().SetIsRegisterPlusOffset(cfa_reg_num, m_initial_sp -
+                        reg_value.GetAsUInt64());
                 m_curr_row_modified = true;
             }
             break;
 
         case EmulateInstruction::eContextAdjustStackPointer:
             // If we have created a frame using the frame pointer, don't follow
             // subsequent adjustments to the stack pointer.
             if (!m_fp_is_cfa)
             {
-                m_curr_row->SetCFAOffset (m_initial_sp - reg_value.GetAsUInt64());
+                m_curr_row->GetCFAValue().SetIsRegisterPlusOffset(
+                        m_curr_row->GetCFAValue().GetRegisterNumber(),
+                        m_initial_sp - reg_value.GetAsUInt64());
                 m_curr_row_modified = true;
             }
             break;
     }
     return true;
 }
 
 

lldb/trunk/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

if (!m_cur_insn.IsValid())
         return false;
     }
 
     unwind_plan.SetPlanValidAddressRange (m_func_bounds);
     unwind_plan.SetRegisterKind (eRegisterKindLLDB);
 
     // At the start of the function, find the CFA by adding wordsize to the SP register
     row->SetOffset (current_func_text_offset);
-    row->SetCFARegister (m_lldb_sp_regnum);
-    row->SetCFAOffset (m_wordsize);
+    row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_sp_regnum, m_wordsize);
 
     // caller's stack pointer value before the call insn is the CFA address
     initial_regloc.SetIsCFAPlusOffset (0);
     row->SetRegisterInfo (m_lldb_sp_regnum, initial_regloc);
 
     // saved instruction pointer can be found at CFA - wordsize.
     current_sp_bytes_offset_from_cfa = m_wordsize;
     initial_regloc.SetAtCFAPlusOffset (-current_sp_bytes_offset_from_cfa);
while (m_func_bounds.ContainsFileAddress (m_cur_insn))
         {
            // Error reading the instruction out of the file, stop scanning
            break;
         }
 
         if (push_rbp_pattern_p ())
         {
             current_sp_bytes_offset_from_cfa += m_wordsize;
-            row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+            row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
             UnwindPlan::Row::RegisterLocation regloc;
-            regloc.SetAtCFAPlusOffset (-row->GetCFAOffset());
+            regloc.SetAtCFAPlusOffset (-row->GetCFAValue().GetOffset());
             row->SetRegisterInfo (m_lldb_fp_regnum, regloc);
             saved_registers[m_machine_fp_regnum] = true;
             row_updated = true;
         }
 
         else if (mov_rsp_rbp_pattern_p ())
         {
-            row->SetCFARegister (m_lldb_fp_regnum);
+            row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_fp_regnum, row->GetCFAValue().GetOffset());
             row_updated = true;
         }
 
         // This is the start() function (or a pthread equivalent), it starts with a pushl $0x0 which puts the
         // saved pc value of 0 on the stack.  In this case we want to pretend we didn't see a stack movement at all --
         // normally the saved pc value is already on the stack by the time the function starts executing.
         else if (push_0_pattern_p ())
         {
         }
 
         else if (push_reg_p (machine_regno))
         {
             current_sp_bytes_offset_from_cfa += m_wordsize;
             // the PUSH instruction has moved the stack pointer - if the CFA is set in terms of the stack pointer,
             // we need to add a new row of instructions.
-            if (row->GetCFARegister() == m_lldb_sp_regnum)
+            if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
-                row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+                row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
             // record where non-volatile (callee-saved, spilled) registers are saved on the stack
             if (nonvolatile_reg_p (machine_regno) 
                 && machine_regno_to_lldb_regno (machine_regno, lldb_regno)
                 && saved_registers[machine_regno] == false)
             {
                 UnwindPlan::Row::RegisterLocation regloc;
while (m_func_bounds.ContainsFileAddress (m_cur_insn))
                 && machine_regno_to_lldb_regno (machine_regno, lldb_regno)
                 && saved_registers[machine_regno] == true)
             {
                 saved_registers[machine_regno] = false;
                 row->RemoveRegisterInfo (lldb_regno);
 
                 if (machine_regno == (int)m_machine_fp_regnum)
                 {
-                    row->SetCFARegister (m_lldb_sp_regnum);
+                    row->GetCFAValue().SetIsRegisterPlusOffset (m_lldb_sp_regnum,
+                            row->GetCFAValue().GetOffset());
                 }
 
                 in_epilogue = true;
                 row_updated = true;
             }
 
             // the POP instruction has moved the stack pointer - if the CFA is set in terms of the stack pointer,
             // we need to add a new row of instructions.
-            if (row->GetCFARegister() == m_lldb_sp_regnum)
+            if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
-                row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+                row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_sp_regnum,
+                        current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
         }
 
         else if (mov_reg_to_local_stack_frame_p (machine_regno, stack_offset) 
                  && nonvolatile_reg_p (machine_regno)
                  && machine_regno_to_lldb_regno (machine_regno, lldb_regno) 
                  && saved_registers[machine_regno] == false)
         {
             saved_registers[machine_regno] = true;
 
             UnwindPlan::Row::RegisterLocation regloc;
 
             // stack_offset for 'movq %r15, -80(%rbp)' will be 80.
             // In the Row, we want to express this as the offset from the CFA.  If the frame base
             // is rbp (like the above instruction), the CFA offset for rbp is probably 16.  So we
             // want to say that the value is stored at the CFA address - 96.
-            regloc.SetAtCFAPlusOffset (-(stack_offset + row->GetCFAOffset()));
+            regloc.SetAtCFAPlusOffset (-(stack_offset + row->GetCFAValue().GetOffset()));
 
             row->SetRegisterInfo (lldb_regno, regloc);
 
             row_updated = true;
         }
 
         else if (sub_rsp_pattern_p (stack_offset))
         {
             current_sp_bytes_offset_from_cfa += stack_offset;
-            if (row->GetCFARegister() == m_lldb_sp_regnum)
+            if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
-                row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+                row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
         }
 
         else if (add_rsp_pattern_p (stack_offset))
         {
             current_sp_bytes_offset_from_cfa -= stack_offset;
-            if (row->GetCFARegister() == m_lldb_sp_regnum)
+            if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
-                row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+                row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
             in_epilogue = true;
         }
 
         else if (ret_pattern_p () && prologue_completed_row.get())
         {
             // Reinstate the saved prologue setup for any instructions
while (m_func_bounds.ContainsFileAddress (m_cur_insn))
 
         // call next instruction
         //     call 0
         //  => pop  %ebx
         // This is used in i386 programs to get the PIC base address for finding global data
         else if (call_next_insn_pattern_p ())
         {
             current_sp_bytes_offset_from_cfa += m_wordsize;
-            if (row->GetCFARegister() == m_lldb_sp_regnum)
+            if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
-                row->SetCFAOffset (current_sp_bytes_offset_from_cfa);
+                row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
         }
 
         if (row_updated)
         {
             if (current_func_text_offset + insn_len < m_func_bounds.GetByteSize())
             {
AssemblyParse_x86::augment_unwind_plan_from_call_site (AddressRange& func, UnwindPlan &unwind_plan)
     // and another row in mid-function.
     if (unwind_plan.GetRowCount() < 2)
         return false;
     UnwindPlan::RowSP first_row = unwind_plan.GetRowAtIndex (0);
     if (first_row->GetOffset() != 0)
         return false;
     uint32_t cfa_reg = m_exe_ctx.GetThreadPtr()->GetRegisterContext()
                        ->ConvertRegisterKindToRegisterNumber (unwind_plan.GetRegisterKind(),
-                                                              first_row->GetCFARegister());
-    if (cfa_reg != m_lldb_sp_regnum || first_row->GetCFAOffset() != m_wordsize)
+                                                              first_row->GetCFAValue().GetRegisterNumber());
+    if (cfa_reg != m_lldb_sp_regnum || first_row->GetCFAValue().GetOffset() != m_wordsize)
         return false;
 
     UnwindPlan::RowSP original_last_row = unwind_plan.GetRowForFunctionOffset (-1);
 
     Target *target = m_exe_ctx.GetTargetPtr();
     m_cur_insn = func.GetBaseAddress();
     uint64_t offset = 0;
     int row_id = 1;
while (func.ContainsFileAddress (m_cur_insn))
             // This won't happen to GCC or clang.
             // In this case, bail out directly.
             return false;
         }
 
         // Inspect the instruction to check if we need a new row for it.
         cfa_reg = m_exe_ctx.GetThreadPtr()->GetRegisterContext()
                   ->ConvertRegisterKindToRegisterNumber (unwind_plan.GetRegisterKind(),
-                                                         row->GetCFARegister());
+                                                         row->GetCFAValue().GetRegisterNumber());
         if (cfa_reg == m_lldb_sp_regnum)
         {
             // CFA register is sp.
 
             // call next instruction
             //     call 0
             //  => pop  %ebx
             if (call_next_insn_pattern_p ())
             {
                 row->SetOffset (offset);
-                row->SetCFAOffset (m_wordsize + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (m_wordsize);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
 
             // push/pop register
             int regno;
             if (push_reg_p (regno))
             {
                 row->SetOffset (offset);
-                row->SetCFAOffset (m_wordsize + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (m_wordsize);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
             if (pop_reg_p (regno))
             {
                 // Technically, this might be a nonvolatile register recover in epilogue.
                 // We should reset RegisterInfo for the register.
                 // But in practice, previous rule for the register is still valid...
                 // So we ignore this case.
 
                 row->SetOffset (offset);
-                row->SetCFAOffset (-m_wordsize + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (-m_wordsize);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
 
             // push imm
             if (push_imm_pattern_p ())
             {
                 row->SetOffset (offset);
-                row->SetCFAOffset (m_wordsize + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (m_wordsize);
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
 
             // add/sub %rsp/%esp
             int amount;
             if (add_rsp_pattern_p (amount))
             {
                 row->SetOffset (offset);
-                row->SetCFAOffset (-amount + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (-amount);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
             if (sub_rsp_pattern_p (amount))
             {
                 row->SetOffset (offset);
-                row->SetCFAOffset (amount + row->GetCFAOffset());
+                row->GetCFAValue().IncOffset (amount);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
             if (ret_pattern_p ())
             {
while (func.ContainsFileAddress (m_cur_insn))
             //  => [0xc3] ret
             if (pop_rbp_pattern_p ())
             {
                 if (target->ReadMemory (m_cur_insn, prefer_file_cache, m_cur_insn_bytes,
                                         1, error) != static_cast<size_t>(-1)
                     && ret_pattern_p ())
                 {
                     row->SetOffset (offset);
-                    row->SetCFARegister (first_row->GetCFARegister());
-                    row->SetCFAOffset (m_wordsize);
+                    row->GetCFAValue().SetIsRegisterPlusOffset (
+                        first_row->GetCFAValue().GetRegisterNumber(), m_wordsize);
 
                     UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                     unwind_plan.InsertRow (new_row);
                     unwind_plan_updated = true;
                     reinstate_unwind_state = true;
                     continue;
                 }
             }
AssemblyParse_x86::get_fast_unwind_plan (AddressRange& func, UnwindPlan &unwind_plan)
 
     pc_reginfo.SetAtCFAPlusOffset (-m_wordsize);
     row->SetRegisterInfo (m_lldb_ip_regnum, pc_reginfo);
 
     sp_reginfo.SetIsCFAPlusOffset (0);
     row->SetRegisterInfo (m_lldb_sp_regnum, sp_reginfo);
 
     // Zero instructions into the function
-    row->SetCFARegister (m_lldb_sp_regnum);
-    row->SetCFAOffset (m_wordsize);
+    row->GetCFAValue().SetIsRegisterPlusOffset (m_lldb_sp_regnum, m_wordsize);
     row->SetOffset (0);
     unwind_plan.AppendRow (row);
     UnwindPlan::Row *newrow = new UnwindPlan::Row;
     *newrow = *row.get();
     row.reset(newrow);
 
     // push %rbp has executed - stack moved, rbp now saved
-    row->SetCFAOffset (2 * m_wordsize);
+    row->GetCFAValue().IncOffset (m_wordsize);
     fp_reginfo.SetAtCFAPlusOffset (2 * -m_wordsize);
     row->SetRegisterInfo (m_lldb_fp_regnum, fp_reginfo);
     row->SetOffset (1);
     unwind_plan.AppendRow (row);
 
     newrow = new UnwindPlan::Row;
     *newrow = *row.get();
     row.reset(newrow);
 
     // mov %rsp, %rbp has executed
-    row->SetCFARegister (m_lldb_fp_regnum);
-    row->SetCFAOffset (2 * m_wordsize);
+    row->GetCFAValue().SetIsRegisterPlusOffset (m_lldb_fp_regnum, 2 * m_wordsize);
     row->SetOffset (prologue_size);     /// 3 or 4 bytes depending on arch
     unwind_plan.AppendRow (row);
 
     newrow = new UnwindPlan::Row;
     *newrow = *row.get();
     row.reset(newrow);
 
     unwind_plan.SetPlanValidAddressRange (func);
UnwindAssembly_x86::AugmentUnwindPlanFromCallSite (AddressRange& func, Thread& thread, UnwindPlan& unwind_plan)
     RegisterNumber pc_regnum (thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 
     // Does this UnwindPlan describe the prologue?  I want to see that the CFA is set
     // in terms of the stack pointer plus an offset, and I want to see that rip is 
     // retrieved at the CFA-wordsize.
     // If there is no description of the prologue, don't try to augment this eh_frame
     // unwinder code, fall back to assembly parsing instead.
 
-    if (first_row->GetCFAType() != UnwindPlan::Row::CFAType::CFAIsRegisterPlusOffset
-        || RegisterNumber (thread, unwind_plan.GetRegisterKind(), first_row->GetCFARegister()) != sp_regnum
-        || first_row->GetCFAOffset() != wordsize)
+    if (first_row->GetCFAValue().GetValueType() != UnwindPlan::Row::CFAValue::isRegisterPlusOffset
+        || RegisterNumber (thread, unwind_plan.GetRegisterKind(),
+            first_row->GetCFAValue().GetRegisterNumber()) != sp_regnum
+        || first_row->GetCFAValue().GetOffset() != wordsize)
     {
         return false;
     }
     UnwindPlan::Row::RegisterLocation first_row_pc_loc;
     if (first_row->GetRegisterInfo (pc_regnum.GetAsKind (unwind_plan.GetRegisterKind()), first_row_pc_loc) == false
         || first_row_pc_loc.IsAtCFAPlusOffset() == false
         || first_row_pc_loc.GetOffset() != -wordsize)
     {
             return false;
     }
 
 
     // It looks like the prologue is described.  
     // Is the epilogue described?  If it is, no need to do any augmentation.
 
     if (first_row != last_row && first_row->GetOffset() != last_row->GetOffset())
     {
         // The first & last row have the same CFA register
         // and the same CFA offset value
         // and the CFA register is esp/rsp (the stack pointer).
 
         // We're checking that both of them have an unwind rule like "CFA=esp+4" or CFA+rsp+8".
 
-        if (first_row->GetCFAType() == last_row->GetCFAType()
-            && first_row->GetCFARegister() == last_row->GetCFARegister()
-            && first_row->GetCFAOffset() == last_row->GetCFAOffset())
+        if (first_row->GetCFAValue().GetValueType() == last_row->GetCFAValue().GetValueType()
+            && first_row->GetCFAValue().GetRegisterNumber() == last_row->GetCFAValue().GetRegisterNumber()
+            && first_row->GetCFAValue().GetOffset() == last_row->GetCFAValue().GetOffset())
         {
             // Get the register locations for eip/rip from the first & last rows.
             // Are they both CFA plus an offset?  Is it the same offset?
 
             UnwindPlan::Row::RegisterLocation last_row_pc_loc;
             if (last_row->GetRegisterInfo (pc_regnum.GetAsKind (unwind_plan.GetRegisterKind()), last_row_pc_loc))
             {
                 if (last_row_pc_loc.IsAtCFAPlusOffset()

lldb/trunk/source/Symbol/CompactUnwindInfo.cpp

CompactUnwindInfo::CreateUnwindPlan_x86_64 (Target &target, FunctionInfo &function_info, UnwindPlan &unwind_plan, Address pc_or_function_start)
     UnwindPlan::RowSP row (new UnwindPlan::Row);
 
     const int wordsize = 8;
     int mode = function_info.encoding & UNWIND_X86_64_MODE_MASK;
     switch (mode)
     {
         case UNWIND_X86_64_MODE_RBP_FRAME:
         {
-            row->SetCFARegister (translate_to_eh_frame_regnum_x86_64 (UNWIND_X86_64_REG_RBP));
-            row->SetCFAOffset (2 * wordsize);
+            row->GetCFAValue().SetIsRegisterPlusOffset (
+                    translate_to_eh_frame_regnum_x86_64 (UNWIND_X86_64_REG_RBP),
+                    2 * wordsize);
             row->SetOffset (0);
             row->SetRegisterLocationToAtCFAPlusOffset (x86_64_eh_regnum::rbp, wordsize * -2, true);
             row->SetRegisterLocationToAtCFAPlusOffset (x86_64_eh_regnum::rip, wordsize * -1, true);
             row->SetRegisterLocationToIsCFAPlusOffset (x86_64_eh_regnum::rsp, 0, true);
             
             uint32_t saved_registers_offset = EXTRACT_BITS (function_info.encoding, UNWIND_X86_64_RBP_FRAME_OFFSET);
 
             uint32_t saved_registers_locations = EXTRACT_BITS (function_info.encoding, UNWIND_X86_64_RBP_FRAME_REGISTERS);
switch (mode)
                     }
                 }
                 else
                 {
                     return false;
                 }
             }
 
-            if (mode == UNWIND_X86_64_MODE_STACK_IND)
-            {
-                row->SetCFAOffset (stack_size);
-            }
-            else
-            {
-                row->SetCFAOffset (stack_size * wordsize);
-            }
+            int32_t offset = mode == UNWIND_X86_64_MODE_STACK_IND ? stack_size : stack_size * wordsize;
+            row->GetCFAValue().SetIsRegisterPlusOffset (x86_64_eh_regnum::rsp, offset);
 
-            row->SetCFARegister (x86_64_eh_regnum::rsp);
             row->SetOffset (0);
             row->SetRegisterLocationToAtCFAPlusOffset (x86_64_eh_regnum::rip, wordsize * -1, true);
             row->SetRegisterLocationToIsCFAPlusOffset (x86_64_eh_regnum::rsp, 0, true);
 
             if (register_count > 0)
             {
 
                 // We need to include (up to) 6 registers in 10 bits.
CompactUnwindInfo::CreateUnwindPlan_i386 (Target &target, FunctionInfo &function_info, UnwindPlan &unwind_plan, Address pc_or_function_start)
     UnwindPlan::RowSP row (new UnwindPlan::Row);
 
     const int wordsize = 4;
     int mode = function_info.encoding & UNWIND_X86_MODE_MASK;
     switch (mode)
     {
         case UNWIND_X86_MODE_EBP_FRAME:
         {
-            row->SetCFARegister (translate_to_eh_frame_regnum_i386 (UNWIND_X86_REG_EBP));
-            row->SetCFAOffset (2 * wordsize);
+            row->GetCFAValue().SetIsRegisterPlusOffset (
+                    translate_to_eh_frame_regnum_i386 (UNWIND_X86_REG_EBP), 2 * wordsize);
             row->SetOffset (0);
             row->SetRegisterLocationToAtCFAPlusOffset (i386_eh_regnum::ebp, wordsize * -2, true);
             row->SetRegisterLocationToAtCFAPlusOffset (i386_eh_regnum::eip, wordsize * -1, true);
             row->SetRegisterLocationToIsCFAPlusOffset (i386_eh_regnum::esp, 0, true);
             
             uint32_t saved_registers_offset = EXTRACT_BITS (function_info.encoding, UNWIND_X86_EBP_FRAME_OFFSET);
 
             uint32_t saved_registers_locations = EXTRACT_BITS (function_info.encoding, UNWIND_X86_EBP_FRAME_REGISTERS);
switch (mode)
                     }
                 }
                 else
                 {
                     return false;
                 }
             }
 
-            row->SetCFARegister (i386_eh_regnum::esp);
-
-            if (mode == UNWIND_X86_MODE_STACK_IND)
-            {
-                row->SetCFAOffset (stack_size);
-            }
-            else
-            {
-                row->SetCFAOffset (stack_size * wordsize);
-            }
-
+            int32_t offset = mode == UNWIND_X86_MODE_STACK_IND ? stack_size : stack_size * wordsize;
+            row->GetCFAValue().SetIsRegisterPlusOffset (i386_eh_regnum::esp, offset);
             row->SetOffset (0);
             row->SetRegisterLocationToAtCFAPlusOffset (i386_eh_regnum::eip, wordsize * -1, true);
             row->SetRegisterLocationToIsCFAPlusOffset (i386_eh_regnum::esp, 0, true);
             
             if (register_count > 0)
             {
 
                 // We need to include (up to) 6 registers in 10 bits.

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

if (length > 0 && ((!m_is_eh_frame && cie_id == UINT32_MAX) || (m_is_eh_frame && cie_id == 0ul)))
             if (extended_opcode == DW_CFA_def_cfa)
             {
                 // Takes two unsigned LEB128 operands representing a register
                 // number and a (non-factored) offset. The required action
                 // is to define the current CFA rule to use the provided
                 // register and offset.
                 uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
                 int op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
-                cie_sp->initial_row.SetCFARegister (reg_num);
-                cie_sp->initial_row.SetCFAOffset (op_offset);
+                cie_sp->initial_row.GetCFAValue().SetIsRegisterPlusOffset (reg_num, op_offset);
                 continue;
             }
             if (primary_opcode == DW_CFA_offset)
             {   
                 // 0x80 - high 2 bits are 0x2, lower 6 bits are register.
                 // Takes two arguments: an unsigned LEB128 constant representing a
                 // factored offset and a register number. The required action is to
                 // change the rule for the register indicated by the register number
while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                 case DW_CFA_def_cfa             : // 0xC    (CFA Definition Instruction)
                     {
                         // Takes two unsigned LEB128 operands representing a register
                         // number and a (non-factored) offset. The required action
                         // is to define the current CFA rule to use the provided
                         // register and offset.
                         reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
                         op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
-                        row->SetCFARegister (reg_num);
-                        row->SetCFAOffset (op_offset);
+                        row->GetCFAValue().SetIsRegisterPlusOffset (reg_num, op_offset);
                     }
                     break;
 
                 case DW_CFA_def_cfa_register    : // 0xD    (CFA Definition Instruction)
                     {
                         // takes a single unsigned LEB128 argument representing a register
                         // number. The required action is to define the current CFA rule to
                         // use the provided register (but to keep the old offset).
                         reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
-                        row->SetCFARegister (reg_num);
+                        row->GetCFAValue().SetIsRegisterPlusOffset (reg_num,
+                                row->GetCFAValue().GetOffset());
                     }
                     break;
 
                 case DW_CFA_def_cfa_offset      : // 0xE    (CFA Definition Instruction)
                     {
                         // Takes a single unsigned LEB128 operand representing a
                         // (non-factored) offset. The required action is to define
                         // the current CFA rule to use the provided offset (but
                         // to keep the old register).
                         op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
-                        row->SetCFAOffset (op_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;
                     }
while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                 case DW_CFA_def_cfa_sf          : // 0x12   (CFA Definition Instruction)
                     {
                         // Takes two operands: an unsigned LEB128 value representing
                         // a register number and a signed LEB128 factored offset.
                         // This instruction is identical to DW_CFA_def_cfa except
                         // that the second operand is signed and factored.
                         reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
                         op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
-                        row->SetCFARegister (reg_num);
-                        row->SetCFAOffset (op_offset);
+                        row->GetCFAValue().SetIsRegisterPlusOffset (reg_num, op_offset);
                     }
                     break;
 
                 case DW_CFA_def_cfa_offset_sf   : // 0x13   (CFA Definition Instruction)
                     {
                         // takes a signed LEB128 operand representing a factored
                         // offset. This instruction is identical to  DW_CFA_def_cfa_offset
                         // except that the operand is signed and factored.
                         op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
-                        row->SetCFAOffset (op_offset);
+                        row->GetCFAValue().SetIsRegisterPlusOffset (
+                                row->GetCFAValue().GetRegisterNumber(), op_offset);
                     }
                     break;
 
                 case DW_CFA_val_expression      :   // 0x16
                     {
                         // 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 register indicated

lldb/trunk/source/Symbol/UnwindPlan.cpp

switch (m_type)
             break;
 
         case atCFAPlusOffset: 
         case isCFAPlusOffset: 
             {
                 s.PutChar('=');
                 if (m_type == atCFAPlusOffset)
                     s.PutChar('[');
-                if (verbose)
-                    s.Printf ("CFA%+d", m_location.offset);
-
-                if (unwind_plan && row)
-                {
-                    const uint32_t cfa_reg = row->GetCFARegister();
-                    const RegisterInfo *cfa_reg_info = unwind_plan->GetRegisterInfo (thread, cfa_reg);
-                    const int32_t offset = row->GetCFAOffset() + m_location.offset;
-                    if (verbose)
-                    {                        
-                        if (cfa_reg_info)
-                            s.Printf (" (%s%+d)",  cfa_reg_info->name, offset); 
-                        else
-                            s.Printf (" (reg(%u)%+d)",  cfa_reg, offset); 
-                    }
-                    else
-                    {
-                        if (cfa_reg_info)
-                            s.Printf ("%s",  cfa_reg_info->name); 
-                        else
-                            s.Printf ("reg(%u)",  cfa_reg); 
-                        if (offset != 0)
-                            s.Printf ("%+d", offset);
-                    }
-                }
                 if (m_type == atCFAPlusOffset)
                     s.PutChar(']');
             }
             break;
 
         case inOtherRegister: 
             {
                 const RegisterInfo *other_reg_info = nullptr;
switch (m_type)
                 else
                     s.PutCString("dwarf-expr");
             }
             break;
         
     }
 }
 
+static void
+DumpRegisterName (Stream &s, const UnwindPlan* unwind_plan, Thread *thread, uint32_t reg_num) {
+    const RegisterInfo *reg_info = unwind_plan->GetRegisterInfo (thread, reg_num);
+    if (reg_info)
+        s.PutCString (reg_info->name);
+    else
+        s.Printf ("reg(%u)", reg_num);
+}
+
+bool
+UnwindPlan::Row::CFAValue::operator == (const UnwindPlan::Row::CFAValue& rhs) const
+{
+    if (m_type == rhs.m_type)
+    {
+        switch (m_type)
+        {
+            case unspecified:
+                return true;
+
+            case isRegisterPlusOffset:
+                return m_value.reg.offset == rhs.m_value.reg.offset;
+
+            case isRegisterDereferenced:
+                return m_value.reg.reg_num == rhs.m_value.reg.reg_num;
+
+            case isDWARFExpression:
+                if (m_value.expr.length == rhs.m_value.expr.length)
+                    return !memcmp (m_value.expr.opcodes, rhs.m_value.expr.opcodes, m_value.expr.length);
+                break;
+        }
+    }
+    return false;
+}
+
+void
+UnwindPlan::Row::CFAValue::Dump(Stream &s, const UnwindPlan* unwind_plan, Thread* thread) const
+{
+    switch(m_type) {
+    case isRegisterPlusOffset:
+        DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num);
+        s.Printf ("%+3d", m_value.reg.offset);
+        break;
+    case isRegisterDereferenced:
+        s.PutChar ('[');
+        DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num);
+        s.PutChar (']');
+        break;
+    case isDWARFExpression:
+        s.PutCString ("dwarf-expr");
+        break;
+    default:
+        s.PutCString ("unspecified");
+        break;
+    }
+}
+
 void
 UnwindPlan::Row::Clear ()
 {
-    m_cfa_type = CFAIsRegisterPlusOffset;
+    m_cfa_value.SetUnspecified();
     m_offset = 0;
-    m_cfa_reg_num = LLDB_INVALID_REGNUM;
-    m_cfa_offset = 0;
     m_register_locations.clear();
 }
 
 void
 UnwindPlan::Row::Dump (Stream& s, const UnwindPlan* unwind_plan, Thread* thread, addr_t base_addr) const
 {
-    const RegisterInfo *reg_info = unwind_plan->GetRegisterInfo (thread, GetCFARegister());
-
     if (base_addr != LLDB_INVALID_ADDRESS)
         s.Printf ("0x%16.16" PRIx64 ": CFA=", base_addr + GetOffset());
     else
         s.Printf ("%4" PRId64 ": CFA=", GetOffset());
             
-    if (reg_info)
-        s.Printf ("%s", reg_info->name);
-    else
-        s.Printf ("reg(%u)", GetCFARegister());
-    s.Printf ("%+3d => ", GetCFAOffset ());
+    m_cfa_value.Dump(s, unwind_plan, thread);
+    s.Printf(" => ");
     for (collection::const_iterator idx = m_register_locations.begin (); idx != m_register_locations.end (); ++idx)
     {
-        reg_info = unwind_plan->GetRegisterInfo (thread, idx->first);
-        if (reg_info)
-            s.Printf ("%s", reg_info->name);
-        else
-            s.Printf ("reg(%u)", idx->first);
+        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_type (CFAIsRegisterPlusOffset),
-    m_cfa_reg_num (LLDB_INVALID_REGNUM),
-    m_cfa_offset (0),
+    m_cfa_value (),
     m_register_locations ()
 {
 }
 
 bool
 UnwindPlan::Row::GetRegisterInfo (uint32_t reg_num, UnwindPlan::Row::RegisterLocation& register_location) const
 {
     collection::const_iterator pos = m_register_locations.find(reg_num);
UnwindPlan::Row::SetRegisterLocationToSame (uint32_t reg_num, bool must_replace)
     if (must_replace && m_register_locations.find(reg_num) == m_register_locations.end())
         return false;
     RegisterLocation reg_loc;
     reg_loc.SetSame();
     m_register_locations[reg_num] = reg_loc;
     return true;
 }
 
-void
-UnwindPlan::Row::SetCFARegister (uint32_t reg_num)
-{
-    m_cfa_reg_num = reg_num;
-}
-
 bool
 UnwindPlan::Row::operator == (const UnwindPlan::Row& rhs) const
 {
-    if (m_offset != rhs.m_offset || m_cfa_reg_num != rhs.m_cfa_reg_num || m_cfa_offset != rhs.m_cfa_offset)
-        return false;
-
-    if (m_cfa_type != rhs.m_cfa_type)
-        return false;
-
-    if (m_cfa_type == CFAIsRegisterPlusOffset)
-    {
-        if (m_cfa_reg_num != rhs.m_cfa_reg_num)
-            return false;
-        if (m_cfa_offset != rhs.m_cfa_offset)
-            return false;
-    }
-    if (m_cfa_type == CFAIsRegisterDereferenced)
-    {
-        if (m_cfa_reg_num != rhs.m_cfa_reg_num)
-            return false;
-    }
-
-    return m_register_locations == rhs.m_register_locations;
+    return m_offset == rhs.m_offset && m_cfa_value == rhs.m_cfa_value &&
+        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
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.
-    if (GetRowAtIndex(0).get() == nullptr || GetRowAtIndex(0)->GetCFARegister() == LLDB_INVALID_REGNUM)
+    // 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)
     {
         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",