[x86] Fix issues with a realigned stack in MSVC compiled applications

[aleksandr.urakov]

Summary

This patch fixes issues with a stack realignment.

MSVC maintains two frame pointers (ebx and ebp) for a realigned stack - one is used for access to function parameters, while another is used for access to locals. To support this the patch:

• adds an alternative frame pointer (ebx);
• considers stack realignment instructions (e.g. and esp, -32);
• along with CFA (Canonical Frame Address) which point to the position next to the saved return address (or to the first parameter on the stack) introduces AFA (Aligned Frame Address) which points to the position of the stack pointer right after realignment. AFA is used for access to registers saved after the realignment (see the test);

Here is an example of the code with the realignment:

struct __declspec(align(256)) OverAligned {
  char c;
};

void foo(int foo_arg) {
  OverAligned oa_foo = { 1 };
  auto aaa_foo = 1234;
}

void bar(int bar_arg) {
  OverAligned oa_bar = { 2 };
  auto aaa_bar = 5678;
  foo(1111);
}

int main() {
  bar(2222);
  return 0;
}

and here is the bar disassembly:

push    ebx
mov     ebx, esp
sub     esp, 8
and     esp, -100h
add     esp, 4
push    ebp
mov     ebp, [ebx+4]
mov     [esp+4], ebp
mov     ebp, esp
sub     esp, 200h
mov     byte ptr [ebp-200h], 2
mov     dword ptr [ebp-4], 5678
push    1111            ; foo_arg
call    j_?foo@@YAXH@Z  ; foo(int)
add     esp, 4
mov     esp, ebp
pop     ebp
mov     esp, ebx
pop     ebx
retn

Btw, it seems that the code of x86AssemblyInspectionEngine has overgrown. I have some ideas how to refactor this, if you don't mind I can do it in the future?

D53086 also contains some discussion on the topic.

[aleksandr.urakov]

Ping! Can you look at this, please?

[jasonmolenda]

Thanks for the ping aleksandr, I have somehow managed to set up my mail rules so I didn't see this. I'll try to look it over later today. Yes, the x86 instruction profiler has definitely overgrown over the years - the ARM64 instruction profiler is probably a better model, but this code is pretty stable so it hasn't been a priority to do anything to it.

[jasonmolenda]

Thanks Aleksandr, this all looks good. I'd like to see a definition of AFA (and we can say "CFA is DWARF's Canonical Frame Address" in the same spot) maybe in UnwindPlan.h, non-Windows people (ok, me) will not know what that is referring to. I was a little worried about and_rsp_pattern_p() but we're not recording the and'ed value. One long standing problem of the UnwindPlan intermediate representation is that it doesn't have any way to represent an alignment involved in the location computation (short of a DWARF expression). This is a problem on AArch32 / armv7 where the NEON registers are saved on higher alignment boundaries than the stack pointer on function call. (if the alignment is less-than or equal-to the stack frame, then there's no align instructions needed in the prologue.) But you're not doing anything like that, no worries.

source/Plugins/Process/Utility/RegisterContextLLDB.h

195 ↗

(On Diff #170194)

Comment update, e.g. Get the Frame Address register for a given frame.

source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

399 ↗

(On Diff #170194)

thanks for using with at&t syntax in these comments ;)

source/Symbol/UnwindPlan.cpp

202 ↗

(On Diff #170194)

What do you think about only printing the AFA= entry if it is != LLDB_INVALID_ADDRESS?

[aleksandr.urakov]

Thank you! I'll update the patch.

source/Plugins/Process/Utility/RegisterContextLLDB.h

195 ↗

(On Diff #170194)

Yes, thanks for pointing to that!

source/Symbol/UnwindPlan.cpp

202 ↗

(On Diff #170194)

Yes, sure!

[aleksandr.urakov]

Update the patch according to comments.

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

 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 // The UnwindPlan object specifies how to unwind out of a function - where this
 // function saves the caller's register values before modifying them (for non-
 // volatile aka saved registers) and how to find this frame's Canonical Frame
-// Address (CFA).
+// Address (CFA) or Aligned Frame Address (AFA).
 
+// CFA is a DWARF's Canonical Frame Address.
 // Most commonly, registers are saved on the stack, offset some bytes from the
 // Canonical Frame Address, or CFA, which is the starting address of this
 // function's stack frame (the CFA is same as the eh_frame's CFA, whatever that
 // may be on a given architecture). The CFA address for the stack frame does
 // not change during the lifetime of the function.
 
+// AFA is an artificially introduced Aligned Frame Address.
+// It is used only for stack frames with realignment (e.g. when some of the
+// locals has an alignment requirement higher than the stack alignment right
+// after the function call). It is used to access register values saved on the
+// stack after the realignment (and so they are inaccessible through the CFA).
+// AFA usually equals the stack pointer value right after the realignment.
+
 // Internally, the UnwindPlan is structured as a vector of register locations
 // organized by code address in the function, showing which registers have been
 // saved at that point and where they are saved. It can be thought of as the
 // expanded table form of the DWARF CFI encoded information.
 
 // Other unwind information sources will be converted into UnwindPlans before
 // being added to a FuncUnwinders object.  The unwind source may be an eh_frame
 // FDE, a DWARF debug_frame FDE, or assembly language based prologue analysis.
public:
       enum RestoreType {
         unspecified,       // not specified, we may be able to assume this
                            // is the same register. gcc doesn't specify all
                            // initial values so we really don't know...
         undefined,         // reg is not available, e.g. volatile reg
         same,              // reg is unchanged
         atCFAPlusOffset,   // reg = deref(CFA + offset)
         isCFAPlusOffset,   // reg = CFA + offset
+        atAFAPlusOffset,   // reg = deref(AFA + offset)
+        isAFAPlusOffset,   // reg = AFA + offset
         inOtherRegister,   // reg = other reg
         atDWARFExpression, // reg = deref(eval(dwarf_expr))
         isDWARFExpression  // reg = eval(dwarf_expr)
       };
 
       RegisterLocation() : m_type(unspecified), m_location() {}
 
       bool operator==(const RegisterLocation &rhs) const;
public:
       bool IsUnspecified() const { return m_type == unspecified; }
 
       bool IsUndefined() const { return m_type == undefined; }
 
       bool IsCFAPlusOffset() const { return m_type == isCFAPlusOffset; }
 
       bool IsAtCFAPlusOffset() const { return m_type == atCFAPlusOffset; }
 
+      bool IsAFAPlusOffset() const { return m_type == isAFAPlusOffset; }
+
+      bool IsAtAFAPlusOffset() const { return m_type == atAFAPlusOffset; }
+
       bool IsInOtherRegister() const { return m_type == inOtherRegister; }
 
       bool IsAtDWARFExpression() const { return m_type == atDWARFExpression; }
 
       bool IsDWARFExpression() const { return m_type == isDWARFExpression; }
 
       void SetAtCFAPlusOffset(int32_t offset) {
         m_type = atCFAPlusOffset;
         m_location.offset = offset;
       }
 
       void SetIsCFAPlusOffset(int32_t offset) {
         m_type = isCFAPlusOffset;
         m_location.offset = offset;
       }
 
+      void SetAtAFAPlusOffset(int32_t offset) {
+        m_type = atAFAPlusOffset;
+        m_location.offset = offset;
+      }
+
+      void SetIsAFAPlusOffset(int32_t offset) {
+        m_type = isAFAPlusOffset;
+        m_location.offset = offset;
+      }
+
       void SetInRegister(uint32_t reg_num) {
         m_type = inOtherRegister;
         m_location.reg_num = reg_num;
       }
 
       uint32_t GetRegisterNumber() const {
         if (m_type == inOtherRegister)
           return m_location.reg_num;
         return LLDB_INVALID_REGNUM;
       }
 
       RestoreType GetLocationType() const { return m_type; }
 
       int32_t GetOffset() const {
-        if (m_type == atCFAPlusOffset || m_type == isCFAPlusOffset)
+        switch(m_type)
+        {
+        case atCFAPlusOffset:
+        case isCFAPlusOffset:
+        case atAFAPlusOffset:
+        case isAFAPlusOffset:
           return m_location.offset;
+        default:
           return 0;
         }
+      }
 
       void GetDWARFExpr(const uint8_t **opcodes, uint16_t &len) const {
         if (m_type == atDWARFExpression || m_type == isDWARFExpression) {
           *opcodes = m_location.expr.opcodes;
           len = m_location.expr.length;
         } else {
           *opcodes = nullptr;
           len = 0;
private:
         // For m_type == atDWARFExpression or m_type == isDWARFExpression
         struct {
           const uint8_t *opcodes;
           uint16_t length;
         } expr;
       } m_location;
     };
 
-    class CFAValue {
+    class FAValue {
     public:
       enum ValueType {
         unspecified,            // not specified
-        isRegisterPlusOffset,   // CFA = register + offset
-        isRegisterDereferenced, // CFA = [reg]
-        isDWARFExpression       // CFA = eval(dwarf_expr)
+        isRegisterPlusOffset,   // FA = register + offset
+        isRegisterDereferenced, // FA = [reg]
+        isDWARFExpression       // FA = eval(dwarf_expr)
       };
 
-      CFAValue() : m_type(unspecified), m_value() {}
+      FAValue() : m_type(unspecified), m_value() {}
 
-      bool operator==(const CFAValue &rhs) const;
+      bool operator==(const FAValue &rhs) const;
 
-      bool operator!=(const CFAValue &rhs) const { return !(*this == rhs); }
+      bool operator!=(const FAValue &rhs) const { return !(*this == rhs); }
 
       void SetUnspecified() { m_type = unspecified; }
 
       bool IsUnspecified() const { return m_type == unspecified; }
 
       bool IsRegisterPlusOffset() const {
         return m_type == isRegisterPlusOffset;
       }
private:
           int32_t offset;
         } reg;
         // For m_type == isDWARFExpression
         struct {
           const uint8_t *opcodes;
           uint16_t length;
         } expr;
       } m_value;
-    }; // class CFAValue
+    }; // class FAValue
 
   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_offset; }
 
     void SetOffset(lldb::addr_t offset) { m_offset = offset; }
 
     void SlideOffset(lldb::addr_t offset) { m_offset += offset; }
 
-    CFAValue &GetCFAValue() { return m_cfa_value; }
+    FAValue &GetCFAValue() { return m_cfa_value; }
+
+    FAValue &GetAFAValue() { return m_afa_value; }
 
     bool SetRegisterLocationToAtCFAPlusOffset(uint32_t reg_num, int32_t offset,
                                               bool can_replace);
 
     bool SetRegisterLocationToIsCFAPlusOffset(uint32_t reg_num, int32_t offset,
                                               bool can_replace);
 
     bool SetRegisterLocationToUndefined(uint32_t reg_num, bool can_replace,
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
 
-    CFAValue m_cfa_value;
+    FAValue m_cfa_value;
+    FAValue m_afa_value;
     collection m_register_locations;
   }; // class Row
 
 public:
   typedef std::shared_ptr<Row> RowSP;
 
   UnwindPlan(lldb::RegisterKind reg_kind)
       : m_row_list(), m_plan_valid_address_range(), m_register_kind(reg_kind),

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

private:
   // Get the contents of a general purpose (address-size) register for this
   // frame
   // (usually retrieved from the next frame)
   bool ReadGPRValue(lldb::RegisterKind register_kind, uint32_t regnum,
                     lldb::addr_t &value);
 
   bool ReadGPRValue(const RegisterNumber &reg_num, lldb::addr_t &value);
 
-  // Get the CFA register for a given frame.
-  bool ReadCFAValueForRow(lldb::RegisterKind register_kind,
-                          const UnwindPlan::RowSP &row, lldb::addr_t &value);
+  // Get the Frame Address register for a given frame.
+  bool ReadFrameAddress(lldb::RegisterKind register_kind,
+                          UnwindPlan::Row::FAValue &fa, lldb::addr_t &address);
 
   lldb::UnwindPlanSP GetFastUnwindPlanForFrame();
 
   lldb::UnwindPlanSP GetFullUnwindPlanForFrame();
 
   void UnwindLogMsg(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 
   void UnwindLogMsgVerbose(const char *fmt, ...)
private:
   lldb::UnwindPlanSP m_full_unwind_plan_sp;
   lldb::UnwindPlanSP m_fallback_unwind_plan_sp; // may be NULL
 
   bool m_all_registers_available; // Can we retrieve all regs or just
                                   // nonvolatile regs?
   int m_frame_type;               // enum FrameType
 
   lldb::addr_t m_cfa;
+  lldb::addr_t m_afa;
   lldb_private::Address m_start_pc;
   lldb_private::Address m_current_pc;
 
   int m_current_offset; // how far into the function we've executed; -1 if
                         // unknown
                         // 0 if no instructions have been executed yet.
 
   int m_current_offset_backed_up_one; // how far into the function we've

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

 RegisterContextLLDB::RegisterContextLLDB(Thread &thread,
                                          const SharedPtr &next_frame,
                                          SymbolContext &sym_ctx,
                                          uint32_t frame_number,
                                          UnwindLLDB &unwind_lldb)
     : RegisterContext(thread, frame_number), m_thread(thread),
       m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(),
       m_fallback_unwind_plan_sp(), m_all_registers_available(false),
-      m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS), m_start_pc(),
+      m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS),
+      m_afa(LLDB_INVALID_ADDRESS), m_start_pc(),
       m_current_pc(), m_current_offset(0), m_current_offset_backed_up_one(0),
       m_sym_ctx(sym_ctx), m_sym_ctx_valid(false), m_frame_number(frame_number),
       m_registers(), m_parent_unwind(unwind_lldb) {
   m_sym_ctx.Clear(false);
   m_sym_ctx_valid = false;
 
   if (IsFrameZero()) {
     InitializeZerothFrame();
void RegisterContextLLDB::InitializeZerothFrame() {
   }
 
   if (!active_row.get()) {
     UnwindLogMsg("could not find an unwindplan row for this frame's pc");
     m_frame_type = eNotAValidFrame;
     return;
   }
 
-  if (!ReadCFAValueForRow(row_register_kind, active_row, m_cfa)) {
+  if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
     // Try the fall back unwind plan since the
     // full unwind plan failed.
     FuncUnwindersSP func_unwinders_sp;
     UnwindPlanSP call_site_unwind_plan;
     bool cfa_status = false;
 
     if (m_sym_ctx_valid) {
       func_unwinders_sp =
if (call_site_unwind_plan.get() != nullptr) {
       if (TryFallbackUnwindPlan())
         cfa_status = true;
     }
     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);
 
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
-               " using %s UnwindPlan",
+               " 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());
 }
 
 // Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on the
 // RegisterContextLLDB "below" it to provide things like its current pc value.
 
 void RegisterContextLLDB::InitializeNonZerothFrame() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
if (abi) {
         m_frame_type = eNormalFrame;
       }
       m_all_registers_available = false;
       m_current_offset = -1;
       m_current_offset_backed_up_one = -1;
       RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
       UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
       if (row.get()) {
-        if (!ReadCFAValueForRow(row_register_kind, row, m_cfa)) {
+        if (!ReadFrameAddress(row_register_kind, row->GetCFAValue(), m_cfa)) {
           UnwindLogMsg("failed to get cfa value");
           if (m_frame_type != eSkipFrame) // don't override eSkipFrame
           {
             m_frame_type = eNotAValidFrame;
           }
           return;
         }
 
+        ReadFrameAddress(row_register_kind, row->GetAFAValue(), m_afa);
+
         // A couple of sanity checks..
         if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1) {
           UnwindLogMsg("could not find a valid cfa address");
           m_frame_type = eNotAValidFrame;
           return;
         }
 
         // m_cfa should point into the stack memory; if we can query memory
if (abi) {
         if (CheckIfLoopingStack()) {
           UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
                        "looping - stopping");
           m_frame_type = eNotAValidFrame;
           return;
         }
       }
 
-      UnwindLogMsg("initialized frame cfa is 0x%" PRIx64, (uint64_t)m_cfa);
+      UnwindLogMsg("initialized frame cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
+                   (uint64_t)m_cfa, (uint64_t)m_afa);
       return;
     }
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("could not find any symbol for this pc, or a default unwind "
                  "plan, to continue unwind.");
     return;
   }
 
void RegisterContextLLDB::InitializeNonZerothFrame() {
   }
 
   if (!active_row.get()) {
     m_frame_type = eNotAValidFrame;
     UnwindLogMsg("could not find unwind row for this pc");
     return;
   }
 
-  if (!ReadCFAValueForRow(row_register_kind, active_row, m_cfa)) {
+  if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
     UnwindLogMsg("failed to get cfa");
     m_frame_type = eNotAValidFrame;
     return;
   }
 
-  UnwindLogMsg("m_cfa = 0x%" PRIx64, m_cfa);
+  ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
+
+  UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
 
   if (CheckIfLoopingStack()) {
     TryFallbackUnwindPlan();
     if (CheckIfLoopingStack()) {
       UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
                    "looping - stopping");
       m_frame_type = eNotAValidFrame;
       return;
     }
   }
 
   UnwindLogMsg("initialized frame current pc is 0x%" PRIx64
-               " cfa is 0x%" PRIx64,
+               " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
                (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
-               (uint64_t)m_cfa);
+               (uint64_t)m_cfa,
+               (uint64_t)m_afa);
 }
 
 bool RegisterContextLLDB::CheckIfLoopingStack() {
   // If we have a bad stack setup, we can get the same CFA value multiple times
   // -- or even more devious, we can actually oscillate between two CFA values.
   // Detect that here and break out to avoid a possible infinite loop in lldb
   // trying to unwind the stack. To detect when we have the same CFA value
   // multiple times, we compare the
if (m_full_unwind_plan_sp) {
           if (active_row) {
             if (arch_default_pc_reg.GetAsKind(unwindplan_registerkind) !=
                     LLDB_INVALID_REGNUM &&
                 active_row->GetRegisterInfo(
                     arch_default_pc_reg.GetAsKind(unwindplan_registerkind),
                     unwindplan_regloc)) {
               can_fetch_pc_value = true;
             }
-            if (ReadCFAValueForRow(unwindplan_registerkind, active_row,
-                                   cfa_value)) {
+            if (ReadFrameAddress(unwindplan_registerkind,
+                                 active_row->GetCFAValue(), cfa_value)) {
               can_fetch_cfa = true;
             }
           }
 
           if (can_fetch_pc_value && can_fetch_cfa) {
             have_unwindplan_regloc = true;
           } else {
             have_unwindplan_regloc = false;
if (unwindplan_regloc.IsAtCFAPlusOffset()) {
     m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
     UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
                  "CFA plus offset %d [saved at 0x%" PRIx64 "]",
                  regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
                  regloc.location.target_memory_location);
     return UnwindLLDB::RegisterSearchResult::eRegisterFound;
   }
 
+  if (unwindplan_regloc.IsAFAPlusOffset()) {
+    if (m_afa == LLDB_INVALID_ADDRESS)
+        return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
+
+    int offset = unwindplan_regloc.GetOffset();
+    regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
+    regloc.location.inferred_value = m_afa + offset;
+    m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
+    UnwindLogMsg("supplying caller's register %s (%d), value is AFA plus "
+                 "offset %d [value is 0x%" PRIx64 "]",
+                 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
+                 regloc.location.inferred_value);
+    return UnwindLLDB::RegisterSearchResult::eRegisterFound;
+  }
+
+  if (unwindplan_regloc.IsAtAFAPlusOffset()) {
+    if (m_afa == LLDB_INVALID_ADDRESS)
+        return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
+
+    int offset = unwindplan_regloc.GetOffset();
+    regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
+    regloc.location.target_memory_location = m_afa + offset;
+    m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
+    UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
+                 "AFA plus offset %d [saved at 0x%" PRIx64 "]",
+                 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
+                 regloc.location.target_memory_location);
+    return UnwindLLDB::RegisterSearchResult::eRegisterFound;
+  }
+
   if (unwindplan_regloc.IsInOtherRegister()) {
     uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
     RegisterNumber row_regnum(m_thread, unwindplan_registerkind,
                               unwindplan_regnum);
     if (row_regnum.GetAsKind(eRegisterKindLLDB) == LLDB_INVALID_REGNUM) {
       UnwindLogMsg("could not supply caller's %s (%d) location - was saved in "
                    "another reg but couldn't convert that regnum",
                    regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
bool RegisterContextLLDB::TryFallbackUnwindPlan() {
   // unwind plan, re-fetch the caller's pc value and CFA value. If they're the
   // same, then the fallback unwind plan provides no benefit.
 
   RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
                            LLDB_REGNUM_GENERIC_PC);
 
   addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
   addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
-  addr_t old_this_frame_cfa_value = m_cfa;
   UnwindLLDB::RegisterLocation regloc;
   if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
                                regloc) ==
       UnwindLLDB::RegisterSearchResult::eRegisterFound) {
     const RegisterInfo *reg_info =
         GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
     if (reg_info) {
       RegisterValue reg_value;
bool RegisterContextLLDB::TryFallbackUnwindPlan() {
   if (m_fallback_unwind_plan_sp.get() == nullptr)
     return true;
 
   // Switch the full UnwindPlan to be the fallback UnwindPlan.  If we decide
   // this isn't working, we need to restore. We'll also need to save & restore
   // the value of the m_cfa ivar.  Save is down below a bit in 'old_cfa'.
   UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
   addr_t old_cfa = m_cfa;
+  addr_t old_afa = m_afa;
 
   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->GetCFAValue().GetValueType() !=
-          UnwindPlan::Row::CFAValue::unspecified) {
+          UnwindPlan::Row::FAValue::unspecified) {
     addr_t new_cfa;
-    if (!ReadCFAValueForRow(m_fallback_unwind_plan_sp->GetRegisterKind(),
-                            active_row, new_cfa) ||
+    if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
+                            active_row->GetCFAValue(), 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;
-      m_cfa = old_cfa;
       return false;
     }
     m_cfa = new_cfa;
 
+    ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
+                     active_row->GetAFAValue(), m_afa);
+
     if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
                                  regloc) ==
         UnwindLLDB::RegisterSearchResult::eRegisterFound) {
       const RegisterInfo *reg_info =
           GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
       if (reg_info) {
         RegisterValue reg_value;
         if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
                                                   reg_value)) {
           new_caller_pc_value = reg_value.GetAsUInt64();
         }
       }
     }
 
     if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
       UnwindLogMsg("failed to get a pc value for the caller frame with the "
                    "fallback unwind plan");
       m_fallback_unwind_plan_sp.reset();
       m_full_unwind_plan_sp = original_full_unwind_plan_sp;
       m_cfa = old_cfa;
+      m_afa = old_afa;
       return false;
     }
 
-    if (old_caller_pc_value != LLDB_INVALID_ADDRESS) {
-      if (old_caller_pc_value == new_caller_pc_value &&
-          new_cfa == old_this_frame_cfa_value) {
-        UnwindLogMsg("fallback unwind plan got the same values for this frame "
-                     "CFA and caller frame pc, not using");
-        m_fallback_unwind_plan_sp.reset();
-        m_full_unwind_plan_sp = original_full_unwind_plan_sp;
-        m_cfa = old_cfa;
-        return false;
-      }
-    }
+        m_cfa == old_cfa &&
+        m_afa == old_afa) {
 
     UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
                  "because UnwindPlan '%s' failed.",
                  m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
                  original_full_unwind_plan_sp->GetSourceName().GetCString());
 
     // We've copied the fallback unwind plan into the full - now clear the
     // fallback.
if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
     return false;
   }
 
   UnwindPlan::RowSP active_row =
       m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 
   if (active_row &&
       active_row->GetCFAValue().GetValueType() !=
-          UnwindPlan::Row::CFAValue::unspecified) {
+          UnwindPlan::Row::FAValue::unspecified) {
     addr_t new_cfa;
-    if (!ReadCFAValueForRow(m_fallback_unwind_plan_sp->GetRegisterKind(),
-                            active_row, new_cfa) ||
+    if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
+                            active_row->GetCFAValue(), 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;
     }
 
+    ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
+                     active_row->GetAFAValue(), m_afa);
+
     m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
     m_fallback_unwind_plan_sp.reset();
 
     m_registers.clear();
 
     m_cfa = new_cfa;
 
     UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
                  m_full_unwind_plan_sp->GetSourceName().GetCString());
     return true;
   }
   return false;
 }
 
-bool RegisterContextLLDB::ReadCFAValueForRow(
-    lldb::RegisterKind row_register_kind, const UnwindPlan::RowSP &row,
-    addr_t &cfa_value) {
+bool RegisterContextLLDB::ReadFrameAddress(
+    lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
+    addr_t &address) {
   RegisterValue reg_value;
 
-  cfa_value = LLDB_INVALID_ADDRESS;
+  address = LLDB_INVALID_ADDRESS;
   addr_t cfa_reg_contents;
 
-  switch (row->GetCFAValue().GetValueType()) {
-  case UnwindPlan::Row::CFAValue::isRegisterDereferenced: {
+  switch (fa.GetValueType()) {
+  case UnwindPlan::Row::FAValue::isRegisterDereferenced: {
     RegisterNumber cfa_reg(m_thread, row_register_kind,
-                           row->GetCFAValue().GetRegisterNumber());
+                           fa.GetRegisterNumber());
     if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
       const RegisterInfo *reg_info =
           GetRegisterInfoAtIndex(cfa_reg.GetAsKind(eRegisterKindLLDB));
       RegisterValue reg_value;
       if (reg_info) {
         Status error = ReadRegisterValueFromMemory(
             reg_info, cfa_reg_contents, reg_info->byte_size, reg_value);
         if (error.Success()) {
-          cfa_value = reg_value.GetAsUInt64();
+          address = 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);
+              cfa_reg_contents, address);
           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);
         }
       }
     }
     break;
   }
-  case UnwindPlan::Row::CFAValue::isRegisterPlusOffset: {
+  case UnwindPlan::Row::FAValue::isRegisterPlusOffset: {
     RegisterNumber cfa_reg(m_thread, row_register_kind,
-                           row->GetCFAValue().GetRegisterNumber());
+                           fa.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->GetCFAValue().GetOffset();
+      address = cfa_reg_contents + fa.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->GetCFAValue().GetOffset());
+          address, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
+          cfa_reg_contents, fa.GetOffset());
       return true;
     }
     break;
   }
-  case UnwindPlan::Row::CFAValue::isDWARFExpression: {
+  case UnwindPlan::Row::FAValue::isDWARFExpression: {
     ExecutionContext exe_ctx(m_thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
-    DataExtractor dwarfdata(row->GetCFAValue().GetDWARFExpressionBytes(),
-                            row->GetCFAValue().GetDWARFExpressionLength(),
+    DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
+                            fa.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
     DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
-                              row->GetCFAValue().GetDWARFExpressionLength());
+                              fa.GetDWARFExpressionLength());
     dwarfexpr.SetRegisterKind(row_register_kind);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
                            &error)) {
-      cfa_value = result.GetScalar().ULongLong();
+      address = result.GetScalar().ULongLong();
 
       UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
-                   cfa_value);
+                   address);
       return true;
     }
     UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
                  error.AsCString());
     break;
   }
   default:
     return false;

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

bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
 
   // 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->GetCFAValue().GetValueType() !=
-          UnwindPlan::Row::CFAValue::isRegisterPlusOffset ||
+          UnwindPlan::Row::FAValue::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(

lldb/trunk/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.h

 private:
   bool nonvolatile_reg_p(int machine_regno);
   bool push_rbp_pattern_p();
   bool push_0_pattern_p();
   bool push_imm_pattern_p();
   bool push_extended_pattern_p();
   bool push_misc_reg_p();
   bool mov_rsp_rbp_pattern_p();
+  bool mov_rsp_rbx_pattern_p();
+  bool mov_rbp_rsp_pattern_p();
+  bool mov_rbx_rsp_pattern_p();
   bool sub_rsp_pattern_p(int &amount);
   bool add_rsp_pattern_p(int &amount);
   bool lea_rsp_pattern_p(int &amount);
   bool lea_rbp_rsp_pattern_p(int &amount);
+  bool lea_rbx_rsp_pattern_p(int &amount);
+  bool and_rsp_pattern_p();
   bool push_reg_p(int &regno);
   bool pop_reg_p(int &regno);
   bool pop_rbp_pattern_p();
   bool pop_misc_reg_p();
   bool leave_pattern_p();
   bool call_next_insn_pattern_p();
   bool mov_reg_to_local_stack_frame_p(int &regno, int &rbp_offset);
   bool ret_pattern_p();
private:
 
   enum { kMaxInstructionByteSize = 32 };
 
   uint8_t *m_cur_insn;
 
   uint32_t m_machine_ip_regnum;
   uint32_t m_machine_sp_regnum;
   uint32_t m_machine_fp_regnum;
+  uint32_t m_machine_alt_fp_regnum;
   uint32_t m_lldb_ip_regnum;
   uint32_t m_lldb_sp_regnum;
   uint32_t m_lldb_fp_regnum;
+  uint32_t m_lldb_alt_fp_regnum;
 
   typedef std::map<uint32_t, lldb_reg_info> MachineRegnumToNameAndLLDBRegnum;
 
   MachineRegnumToNameAndLLDBRegnum m_reg_map;
 
   lldb_private::ArchSpec m_arch;
   CPU m_cpu;
   int m_wordsize;

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

void x86AssemblyInspectionEngine::Initialize(RegisterContextSP &reg_ctx) {
 
   if (reg_ctx.get() == nullptr)
     return;
 
   if (m_cpu == k_i386) {
     m_machine_ip_regnum = k_machine_eip;
     m_machine_sp_regnum = k_machine_esp;
     m_machine_fp_regnum = k_machine_ebp;
+    m_machine_alt_fp_regnum = k_machine_ebx;
     m_wordsize = 4;
 
     struct lldb_reg_info reginfo;
     reginfo.name = "eax";
     m_reg_map[k_machine_eax] = reginfo;
     reginfo.name = "edx";
     m_reg_map[k_machine_edx] = reginfo;
     reginfo.name = "esp";
if (m_cpu == k_i386) {
     reginfo.name = "ebp";
     m_reg_map[k_machine_ebp] = reginfo;
     reginfo.name = "edi";
     m_reg_map[k_machine_edi] = reginfo;
   } else {
     m_machine_ip_regnum = k_machine_rip;
     m_machine_sp_regnum = k_machine_rsp;
     m_machine_fp_regnum = k_machine_rbp;
+    m_machine_alt_fp_regnum = k_machine_rbx;
     m_wordsize = 8;
 
     struct lldb_reg_info reginfo;
     reginfo.name = "rax";
     m_reg_map[k_machine_rax] = reginfo;
     reginfo.name = "rdx";
     m_reg_map[k_machine_rdx] = reginfo;
     reginfo.name = "rsp";
if (ri)
       it->second.lldb_regnum = ri->kinds[eRegisterKindLLDB];
   }
 
   uint32_t lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_sp_regnum, lldb_regno))
     m_lldb_sp_regnum = lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_fp_regnum, lldb_regno))
     m_lldb_fp_regnum = lldb_regno;
+  if (machine_regno_to_lldb_regno(m_machine_alt_fp_regnum, lldb_regno))
+    m_lldb_alt_fp_regnum = lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_ip_regnum, lldb_regno))
     m_lldb_ip_regnum = lldb_regno;
 
   m_register_map_initialized = true;
 }
 
 void x86AssemblyInspectionEngine::Initialize(
     std::vector<lldb_reg_info> &reg_info) {
void x86AssemblyInspectionEngine::Initialize(
 
   if (m_cpu == k_cpu_unspecified)
     return;
 
   if (m_cpu == k_i386) {
     m_machine_ip_regnum = k_machine_eip;
     m_machine_sp_regnum = k_machine_esp;
     m_machine_fp_regnum = k_machine_ebp;
+    m_machine_alt_fp_regnum = k_machine_ebx;
     m_wordsize = 4;
 
     struct lldb_reg_info reginfo;
     reginfo.name = "eax";
     m_reg_map[k_machine_eax] = reginfo;
     reginfo.name = "edx";
     m_reg_map[k_machine_edx] = reginfo;
     reginfo.name = "esp";
if (m_cpu == k_i386) {
     reginfo.name = "ebp";
     m_reg_map[k_machine_ebp] = reginfo;
     reginfo.name = "edi";
     m_reg_map[k_machine_edi] = reginfo;
   } else {
     m_machine_ip_regnum = k_machine_rip;
     m_machine_sp_regnum = k_machine_rsp;
     m_machine_fp_regnum = k_machine_rbp;
+    m_machine_alt_fp_regnum = k_machine_rbx;
     m_wordsize = 8;
 
     struct lldb_reg_info reginfo;
     reginfo.name = "rax";
     m_reg_map[k_machine_rax] = reginfo;
     reginfo.name = "rdx";
     m_reg_map[k_machine_rdx] = reginfo;
     reginfo.name = "rsp";
for (MachineRegnumToNameAndLLDBRegnum::iterator it = m_reg_map.begin();
     }
   }
 
   uint32_t lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_sp_regnum, lldb_regno))
     m_lldb_sp_regnum = lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_fp_regnum, lldb_regno))
     m_lldb_fp_regnum = lldb_regno;
+  if (machine_regno_to_lldb_regno(m_machine_alt_fp_regnum, lldb_regno))
+    m_lldb_alt_fp_regnum = lldb_regno;
   if (machine_regno_to_lldb_regno(m_machine_ip_regnum, lldb_regno))
     m_lldb_ip_regnum = lldb_regno;
 
   m_register_map_initialized = true;
 }
 
 // This function expects an x86 native register number (i.e. the bits stripped
 // out of the actual instruction), not an lldb register number.
if (m_wordsize == 8 && *p == 0x48)
     p++;
   if (*(p) == 0x8b && *(p + 1) == 0xec)
     return true;
   if (*(p) == 0x89 && *(p + 1) == 0xe5)
     return true;
   return false;
 }
 
+// movq %rsp, %rbx [0x48 0x8b 0xdc] or [0x48 0x89 0xe3]
+// movl %esp, %ebx [0x8b 0xdc] or [0x89 0xe3]
+bool x86AssemblyInspectionEngine::mov_rsp_rbx_pattern_p() {
+  uint8_t *p = m_cur_insn;
+  if (m_wordsize == 8 && *p == 0x48)
+    p++;
+  if (*(p) == 0x8b && *(p + 1) == 0xdc)
+    return true;
+  if (*(p) == 0x89 && *(p + 1) == 0xe3)
+    return true;
+  return false;
+}
+
+// movq %rbp, %rsp [0x48 0x8b 0xe5] or [0x48 0x89 0xec]
+// movl %ebp, %esp [0x8b 0xe5] or [0x89 0xec]
+bool x86AssemblyInspectionEngine::mov_rbp_rsp_pattern_p() {
+  uint8_t *p = m_cur_insn;
+  if (m_wordsize == 8 && *p == 0x48)
+    p++;
+  if (*(p) == 0x8b && *(p + 1) == 0xe5)
+    return true;
+  if (*(p) == 0x89 && *(p + 1) == 0xec)
+    return true;
+  return false;
+}
+
+// movq %rbx, %rsp [0x48 0x8b 0xe3] or [0x48 0x89 0xdc]
+// movl %ebx, %esp [0x8b 0xe3] or [0x89 0xdc]
+bool x86AssemblyInspectionEngine::mov_rbx_rsp_pattern_p() {
+  uint8_t *p = m_cur_insn;
+  if (m_wordsize == 8 && *p == 0x48)
+    p++;
+  if (*(p) == 0x8b && *(p + 1) == 0xe3)
+    return true;
+  if (*(p) == 0x89 && *(p + 1) == 0xdc)
+    return true;
+  return false;
+}
+
 // subq $0x20, %rsp
 bool x86AssemblyInspectionEngine::sub_rsp_pattern_p(int &amount) {
   uint8_t *p = m_cur_insn;
   if (m_wordsize == 8 && *p == 0x48)
     p++;
   // 8-bit immediate operand
   if (*p == 0x83 && *(p + 1) == 0xec) {
     amount = (int8_t) * (p + 2);
bool x86AssemblyInspectionEngine::lea_rbp_rsp_pattern_p(int &amount) {
   if (*p == 0xa5) {
     amount = (int32_t)extract_4(p + 1);
     return true;
   }
 
   return false;
 }
 
+// lea -0x28(%ebx), %esp
+// (32-bit and 64-bit variants, 8-bit and 32-bit displacement)
+bool x86AssemblyInspectionEngine::lea_rbx_rsp_pattern_p(int &amount) {
+  uint8_t *p = m_cur_insn;
+  if (m_wordsize == 8 && *p == 0x48)
+    p++;
+
+  // Check opcode
+  if (*p != 0x8d)
+    return false;
+  ++p;
+
+  // 8 bit displacement
+  if (*p == 0x63) {
+    amount = (int8_t)p[1];
+    return true;
+  }
+
+  // 32 bit displacement
+  if (*p == 0xa3) {
+    amount = (int32_t)extract_4(p + 1);
+    return true;
+  }
+
+  return false;
+}
+
+// and -0xfffffff0, %esp
+// (32-bit and 64-bit variants, 8-bit and 32-bit displacement)
+bool x86AssemblyInspectionEngine::and_rsp_pattern_p() {
+  uint8_t *p = m_cur_insn;
+  if (m_wordsize == 8 && *p == 0x48)
+    p++;
+
+  if (*p != 0x81 && *p != 0x83)
+    return false;
+
+  return *++p == 0xe4;
+}
+
 // popq %rbx
 // popl %ebx
 bool x86AssemblyInspectionEngine::pop_reg_p(int &regno) {
   uint8_t *p = m_cur_insn;
   int regno_prefix_bit = 0;
   // If we have a rex prefix byte, check to see if a B bit is set
   if (m_wordsize == 8 && *p == 0x41) {
     regno_prefix_bit = 1 << 3;
bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
 
   if (data == nullptr || size == 0)
     return false;
 
   if (m_register_map_initialized == false)
     return false;
 
   addr_t current_func_text_offset = 0;
-  int current_sp_bytes_offset_from_cfa = 0;
+  int current_sp_bytes_offset_from_fa = 0;
+  bool is_aligned = false;
   UnwindPlan::Row::RegisterLocation initial_regloc;
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   unwind_plan.SetPlanValidAddressRange(func_range);
   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->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);
+  current_sp_bytes_offset_from_fa = m_wordsize;
+  initial_regloc.SetAtCFAPlusOffset(-current_sp_bytes_offset_from_fa);
   row->SetRegisterInfo(m_lldb_ip_regnum, initial_regloc);
 
   unwind_plan.AppendRow(row);
 
   // Allocate a new Row, populate it with the existing Row contents.
   UnwindPlan::Row *newrow = new UnwindPlan::Row;
   *newrow = *row.get();
   row.reset(newrow);
 
   // Track which registers have been saved so far in the prologue. If we see
   // another push of that register, it's not part of the prologue. The register
   // numbers used here are the machine register #'s (i386_register_numbers,
   // x86_64_register_numbers).
   std::vector<bool> saved_registers(32, false);
 
   // Once the prologue has completed we'll save a copy of the unwind
   // instructions If there is an epilogue in the middle of the function, after
   // that epilogue we'll reinstate the unwind setup -- we assume that some code
   // path jumps over the mid-function epilogue
 
   UnwindPlan::RowSP prologue_completed_row; // copy of prologue row of CFI
   int prologue_completed_sp_bytes_offset_from_cfa; // The sp value before the
                                                    // epilogue started executed
+  bool prologue_completed_is_aligned;
   std::vector<bool> prologue_completed_saved_registers;
 
   while (current_func_text_offset < size) {
     int stack_offset, insn_len;
     int machine_regno;   // register numbers masked directly out of instructions
     uint32_t lldb_regno; // register numbers in lldb's eRegisterKindLLDB
                          // numbering scheme
 
     bool in_epilogue = false; // we're in the middle of an epilogue sequence
     bool row_updated = false; // The UnwindPlan::Row 'row' has been updated
 
     m_cur_insn = data + current_func_text_offset;
     if (!instruction_length(m_cur_insn, insn_len, size - current_func_text_offset)
         || insn_len == 0 
         || insn_len > kMaxInstructionByteSize) {
       // An unrecognized/junk instruction
       break;
     }
 
-    if (push_rbp_pattern_p()) {
-      current_sp_bytes_offset_from_cfa += m_wordsize;
-      row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
-      UnwindPlan::Row::RegisterLocation regloc;
-      regloc.SetAtCFAPlusOffset(-row->GetCFAValue().GetOffset());
-      row->SetRegisterInfo(m_lldb_fp_regnum, regloc);
-      saved_registers[m_machine_fp_regnum] = true;
+    auto &cfa_value = row->GetCFAValue();
+    auto &afa_value = row->GetAFAValue();
+    auto fa_value_ptr = is_aligned ? &afa_value : &cfa_value;
+
+    if (mov_rsp_rbp_pattern_p()) {
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_fp_regnum, fa_value_ptr->GetOffset());
         row_updated = true;
       }
+    }
 
-    else if (mov_rsp_rbp_pattern_p()) {
-      row->GetCFAValue().SetIsRegisterPlusOffset(
-          m_lldb_fp_regnum, row->GetCFAValue().GetOffset());
+    else if (mov_rsp_rbx_pattern_p()) {
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_alt_fp_regnum, fa_value_ptr->GetOffset());
+        row_updated = true;
+      }
+    }
+
+    else if (and_rsp_pattern_p()) {
+      current_sp_bytes_offset_from_fa = 0;
+      afa_value.SetIsRegisterPlusOffset(
+          m_lldb_sp_regnum, current_sp_bytes_offset_from_fa);
+      fa_value_ptr = &afa_value;
+      is_aligned = true;
       row_updated = true;
     }
 
+    else if (mov_rbp_rsp_pattern_p()) {
+      if (is_aligned && cfa_value.GetRegisterNumber() == m_lldb_fp_regnum)
+      {
+        is_aligned = false;
+        fa_value_ptr = &cfa_value;
+        afa_value.SetUnspecified();
+        row_updated = true;
+      }
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_fp_regnum)
+        current_sp_bytes_offset_from_fa = fa_value_ptr->GetOffset();
+    }
+
+    else if (mov_rbx_rsp_pattern_p()) {
+      if (is_aligned && cfa_value.GetRegisterNumber() == m_lldb_alt_fp_regnum)
+      {
+        is_aligned = false;
+        fa_value_ptr = &cfa_value;
+        afa_value.SetUnspecified();
+        row_updated = true;
+      }
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_alt_fp_regnum)
+        current_sp_bytes_offset_from_fa = fa_value_ptr->GetOffset();
+    }
+
     // 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
+      current_sp_bytes_offset_from_fa += m_wordsize;
+      // the PUSH instruction has moved the stack pointer - if the FA is set
       // in terms of the stack pointer, we need to add a new row of
       // instructions.
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         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;
-        regloc.SetAtCFAPlusOffset(-current_sp_bytes_offset_from_cfa);
+        if (is_aligned)
+            regloc.SetAtAFAPlusOffset(-current_sp_bytes_offset_from_fa);
+        else
+            regloc.SetAtCFAPlusOffset(-current_sp_bytes_offset_from_fa);
         row->SetRegisterInfo(lldb_regno, regloc);
         saved_registers[machine_regno] = true;
         row_updated = true;
       }
     }
 
     else if (pop_reg_p(machine_regno)) {
-      current_sp_bytes_offset_from_cfa -= m_wordsize;
+      current_sp_bytes_offset_from_fa -= m_wordsize;
 
       if (nonvolatile_reg_p(machine_regno) &&
           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->GetCFAValue().SetIsRegisterPlusOffset(
-              m_lldb_sp_regnum, row->GetCFAValue().GetOffset());
+        if (lldb_regno == fa_value_ptr->GetRegisterNumber()) {
+          fa_value_ptr->SetIsRegisterPlusOffset(
+              m_lldb_sp_regnum, fa_value_ptr->GetOffset());
         }
 
         in_epilogue = true;
         row_updated = true;
       }
 
-      // the POP instruction has moved the stack pointer - if the CFA is set in
+      // the POP instruction has moved the stack pointer - if the FA is set in
       // terms of the stack pointer, we need to add a new row of instructions.
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetIsRegisterPlusOffset(
-            m_lldb_sp_regnum, current_sp_bytes_offset_from_cfa);
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_sp_regnum, current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
     }
 
     else if (pop_misc_reg_p()) {
-      current_sp_bytes_offset_from_cfa -= m_wordsize;
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetIsRegisterPlusOffset(
-            m_lldb_sp_regnum, current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa -= m_wordsize;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_sp_regnum, current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
     }
 
     // The LEAVE instruction moves the value from rbp into rsp and pops a value
     // off the stack into rbp (restoring the caller's rbp value). It is the
     // opposite of ENTER, or 'push rbp, mov rsp rbp'.
     else if (leave_pattern_p()) {
-      // We're going to copy the value in rbp into rsp, so re-set the sp offset
-      // based on the CFAValue.  Also, adjust it to recognize that we're
-      // popping the saved rbp value off the stack.
-      current_sp_bytes_offset_from_cfa = row->GetCFAValue().GetOffset();
-      current_sp_bytes_offset_from_cfa -= m_wordsize;
-      row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
-
-      // rbp is restored to the caller's value
+      if (saved_registers[m_machine_fp_regnum]) {
         saved_registers[m_machine_fp_regnum] = false;
         row->RemoveRegisterInfo(m_lldb_fp_regnum);
 
-      // cfa is now in terms of rsp again.
-      row->GetCFAValue().SetIsRegisterPlusOffset(
-          m_lldb_sp_regnum, row->GetCFAValue().GetOffset());
-      row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+        row_updated = true;
+      }
 
-      in_epilogue = true;
+      if (is_aligned && cfa_value.GetRegisterNumber() == m_lldb_fp_regnum)
+      {
+        is_aligned = false;
+        fa_value_ptr = &cfa_value;
+        afa_value.SetUnspecified();
+        row_updated = true;
+      }
+
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_fp_regnum)
+      {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_sp_regnum, fa_value_ptr->GetOffset());
+
+        current_sp_bytes_offset_from_fa = fa_value_ptr->GetOffset();
+      }
+
+      current_sp_bytes_offset_from_fa -= m_wordsize;
+
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetIsRegisterPlusOffset(
+            m_lldb_sp_regnum, current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
 
+      in_epilogue = 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 -
+      // want to express this as the offset from the FA.  If the frame base is
+      // rbp (like the above instruction), the FA offset for rbp is probably
+      // 16.  So we want to say that the value is stored at the FA address -
       // 96.
-      regloc.SetAtCFAPlusOffset(
-          -(stack_offset + row->GetCFAValue().GetOffset()));
+      if (is_aligned)
+          regloc.SetAtAFAPlusOffset(-(stack_offset + fa_value_ptr->GetOffset()));
+      else
+          regloc.SetAtCFAPlusOffset(-(stack_offset + fa_value_ptr->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->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa += stack_offset;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
     }
 
     else if (add_rsp_pattern_p(stack_offset)) {
-      current_sp_bytes_offset_from_cfa -= stack_offset;
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa -= stack_offset;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
       in_epilogue = true;
     }
 
     else if (push_extended_pattern_p() || push_imm_pattern_p() ||
              push_misc_reg_p()) {
-      current_sp_bytes_offset_from_cfa += m_wordsize;
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa += m_wordsize;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
     }
 
     else if (lea_rsp_pattern_p(stack_offset)) {
-      current_sp_bytes_offset_from_cfa -= stack_offset;
-      if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa -= stack_offset;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
       if (stack_offset > 0)
         in_epilogue = true;
     }
 
-    else if (lea_rbp_rsp_pattern_p(stack_offset) &&
-             row->GetCFAValue().GetRegisterNumber() == m_lldb_fp_regnum) {
-      current_sp_bytes_offset_from_cfa =
-          row->GetCFAValue().GetOffset() - stack_offset;
+    else if (lea_rbp_rsp_pattern_p(stack_offset)) {
+      if (is_aligned &&
+          cfa_value.GetRegisterNumber() == m_lldb_fp_regnum) {
+        is_aligned = false;
+        fa_value_ptr = &cfa_value;
+        afa_value.SetUnspecified();
+        row_updated = true;
+      }
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_fp_regnum) {
+        current_sp_bytes_offset_from_fa =
+          fa_value_ptr->GetOffset() - stack_offset;
+      }
+    }
+
+    else if (lea_rbx_rsp_pattern_p(stack_offset)) {
+      if (is_aligned &&
+          cfa_value.GetRegisterNumber() == m_lldb_alt_fp_regnum) {
+        is_aligned = false;
+        fa_value_ptr = &cfa_value;
+        afa_value.SetUnspecified();
+        row_updated = true;
+      }
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_alt_fp_regnum) {
+        current_sp_bytes_offset_from_fa = fa_value_ptr->GetOffset() - stack_offset;
+      }
     }
 
     else if (ret_pattern_p() && prologue_completed_row.get()) {
       // Reinstate the saved prologue setup for any instructions that come
       // after the ret instruction
 
       UnwindPlan::Row *newrow = new UnwindPlan::Row;
       *newrow = *prologue_completed_row.get();
       row.reset(newrow);
-      current_sp_bytes_offset_from_cfa =
+      current_sp_bytes_offset_from_fa =
           prologue_completed_sp_bytes_offset_from_cfa;
+      is_aligned = prologue_completed_is_aligned;
 
       saved_registers.clear();
       saved_registers.resize(prologue_completed_saved_registers.size(), false);
       for (size_t i = 0; i < prologue_completed_saved_registers.size(); ++i) {
         saved_registers[i] = prologue_completed_saved_registers[i];
       }
 
       in_epilogue = true;
       row_updated = true;
     }
 
     // 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->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum) {
-        row->GetCFAValue().SetOffset(current_sp_bytes_offset_from_cfa);
+      current_sp_bytes_offset_from_fa += m_wordsize;
+      if (fa_value_ptr->GetRegisterNumber() == m_lldb_sp_regnum) {
+        fa_value_ptr->SetOffset(current_sp_bytes_offset_from_fa);
         row_updated = true;
       }
     }
 
     if (row_updated) {
       if (current_func_text_offset + insn_len < size) {
         row->SetOffset(current_func_text_offset + insn_len);
         unwind_plan.AppendRow(row);
if (in_epilogue == false && row_updated) {
         prologue_completed_saved_registers[i] = saved_registers[i];
       }
     }
 
     // We may change the sp value without adding a new Row necessarily -- keep
     // track of it either way.
     if (in_epilogue == false) {
       prologue_completed_sp_bytes_offset_from_cfa =
-          current_sp_bytes_offset_from_cfa;
+          current_sp_bytes_offset_from_fa;
+      prologue_completed_is_aligned = is_aligned;
     }
 
     m_cur_insn = m_cur_insn + insn_len;
     current_func_text_offset += insn_len;
   }
 
   unwind_plan.SetSourceName("assembly insn profiling");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);

lldb/trunk/source/Symbol/UnwindPlan.cpp

if (m_type == rhs.m_type) {
     switch (m_type) {
     case unspecified:
     case undefined:
     case same:
       return true;
 
     case atCFAPlusOffset:
     case isCFAPlusOffset:
+    case atAFAPlusOffset:
+    case isAFAPlusOffset:
       return m_location.offset == rhs.m_location.offset;
 
     case inOtherRegister:
       return m_location.reg_num == rhs.m_location.reg_num;
 
     case atDWARFExpression:
     case isDWARFExpression:
       if (m_location.expr.length == rhs.m_location.expr.length)
case isCFAPlusOffset: {
     s.PutChar('=');
     if (m_type == atCFAPlusOffset)
       s.PutChar('[');
     s.Printf("CFA%+d", m_location.offset);
     if (m_type == atCFAPlusOffset)
       s.PutChar(']');
   } break;
 
+  case atAFAPlusOffset:
+  case isAFAPlusOffset: {
+    s.PutChar('=');
+    if (m_type == atAFAPlusOffset)
+      s.PutChar('[');
+    s.Printf("AFA%+d", m_location.offset);
+    if (m_type == atAFAPlusOffset)
+      s.PutChar(']');
+  } break;
+
   case inOtherRegister: {
     const RegisterInfo *other_reg_info = nullptr;
     if (unwind_plan)
       other_reg_info = unwind_plan->GetRegisterInfo(thread, m_location.reg_num);
     if (other_reg_info)
       s.Printf("=%s", other_reg_info->name);
     else
       s.Printf("=reg(%u)", m_location.reg_num);
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 {
+bool UnwindPlan::Row::FAValue::
+operator==(const UnwindPlan::Row::FAValue &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,
+void UnwindPlan::Row::FAValue::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_value.SetUnspecified();
+  m_afa_value.SetUnspecified();
   m_offset = 0;
   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
     s.Printf("%4" PRId64 ": CFA=", GetOffset());
 
   m_cfa_value.Dump(s, unwind_plan, thread);
+
+  if (!m_afa_value.IsUnspecified()) {
+    s.Printf(" AFA=");
+    m_afa_value.Dump(s, unwind_plan, thread);
+  }
+
   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_register_locations() {}
+UnwindPlan::Row::Row()
+    : m_offset(0), m_cfa_value(), m_afa_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);
   if (pos != m_register_locations.end()) {
     register_location = pos->second;
     return true;
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 &&
-         m_register_locations == rhs.m_register_locations;
+  return m_offset == rhs.m_offset &&
+      m_cfa_value == rhs.m_cfa_value &&
+      m_afa_value == rhs.m_afa_value &&
 }
 
 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;
if (GetRowCount() == 0) {
     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)->GetCFAValue().GetValueType() ==
-          Row::CFAValue::unspecified) {
+          Row::FAValue::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",
                     m_source_name.GetCString(), s.GetData());
       } else {

lldb/trunk/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp

std::unique_ptr<x86AssemblyInspectionEngine> Geti386Inspector() {
   }
 
   engine->Initialize(lldb_regnums);
   return engine;
 }
 
 namespace lldb_private {
 static std::ostream &operator<<(std::ostream &OS,
-                                const UnwindPlan::Row::CFAValue &CFA) {
+                                const UnwindPlan::Row::FAValue &CFA) {
   StreamString S;
   CFA.Dump(S, nullptr, nullptr);
   return OS << S.GetData();
 }
 } // namespace lldb_private
 
 TEST_F(Testx86AssemblyInspectionEngine, TestSimple64bitFrameFunction) {
   std::unique_ptr<x86AssemblyInspectionEngine> engine = Getx86_64Inspector();
uint8_t data[] = {
       0xc3,             // retl
   };
 
   AddressRange sample_range(0x1000, sizeof(data));
   UnwindPlan plan(eRegisterKindLLDB);
   ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
                                                            sample_range, plan));
 
-  UnwindPlan::Row::CFAValue esp_plus_4, esp_plus_8, ebp_plus_8;
+  UnwindPlan::Row::FAValue esp_plus_4, esp_plus_8, ebp_plus_8;
   esp_plus_4.SetIsRegisterPlusOffset(k_esp, 4);
   esp_plus_8.SetIsRegisterPlusOffset(k_esp, 8);
   ebp_plus_8.SetIsRegisterPlusOffset(k_ebp, 8);
 
   EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
   EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
   for (size_t i = 3; i < sizeof(data) - 2; ++i)
     EXPECT_EQ(ebp_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
uint8_t data[] = {
       0xc3,                                     // retq
   };
 
   AddressRange sample_range(0x1000, sizeof(data));
   UnwindPlan plan(eRegisterKindLLDB);
   ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
                                                            sample_range, plan));
 
-  UnwindPlan::Row::CFAValue rsp_plus_8, rsp_plus_16, rbp_plus_16;
+  UnwindPlan::Row::FAValue rsp_plus_8, rsp_plus_16, rbp_plus_16;
   rsp_plus_8.SetIsRegisterPlusOffset(k_rsp, 8);
   rsp_plus_16.SetIsRegisterPlusOffset(k_rsp, 16);
   rbp_plus_16.SetIsRegisterPlusOffset(k_rbp, 16);
 
   EXPECT_EQ(rsp_plus_8, plan.GetRowForFunctionOffset(0)->GetCFAValue());
   EXPECT_EQ(rsp_plus_16, plan.GetRowForFunctionOffset(1)->GetCFAValue());
   for (size_t i = 4; i < sizeof(data) - 2; ++i)
     EXPECT_EQ(rbp_plus_16, plan.GetRowForFunctionOffset(i)->GetCFAValue())
         << "i: " << i;
   EXPECT_EQ(rsp_plus_8,
             plan.GetRowForFunctionOffset(sizeof(data) - 1)->GetCFAValue());
 }
 
+TEST_F(Testx86AssemblyInspectionEngine, TestStackRealignMSVC_i386) {
+  std::unique_ptr<x86AssemblyInspectionEngine> engine = Geti386Inspector();
+
+  uint8_t data[] = {
+      0x53,                               // offset 00 -- pushl %ebx
+      0x8b, 0xdc,                         // offset 01 -- movl %esp, %ebx
+      0x83, 0xec, 0x08,                   // offset 03 -- subl $8, %esp
+      0x81, 0xe4, 0x00, 0xff, 0xff, 0xff, // offset 06 -- andl $-256, %esp
+      0x83, 0xc4, 0x04,                   // offset 12 -- addl $4, %esp
+      0x55,                               // offset 15 -- pushl %ebp
+      0x8b, 0xec,                         // offset 16 -- movl %esp, %ebp
+      0x81, 0xec, 0x00, 0x02, 0x00, 0x00, // offset 18 -- subl $512, %esp
+      0x89, 0x7d, 0xfc,                   // offset 24 -- movl %edi, -4(%ebp)
+      0x8b, 0xe5,                         // offset 27 -- movl %ebp, %esp
+      0x5d,                               // offset 29 -- popl %ebp
+      0x8b, 0xe3,                         // offset 30 -- movl %ebx, %esp
+      0x5b,                               // offset 32 -- popl %ebx
+      0xc3                                // offset 33 -- retl
+  };
+
+  AddressRange sample_range(0x1000, sizeof(data));
+  UnwindPlan plan(eRegisterKindLLDB);
+  ASSERT_TRUE(engine->GetNonCallSiteUnwindPlanFromAssembly(data, sizeof(data),
+                                                           sample_range, plan));
+
+  UnwindPlan::Row::FAValue esp_minus_4, esp_plus_0, esp_plus_4, esp_plus_8,
+      ebx_plus_8, ebp_plus_0;
+  esp_minus_4.SetIsRegisterPlusOffset(k_esp, -4);
+  esp_plus_0.SetIsRegisterPlusOffset(k_esp, 0);
+  esp_plus_4.SetIsRegisterPlusOffset(k_esp, 4);
+  esp_plus_8.SetIsRegisterPlusOffset(k_esp, 8);
+  ebx_plus_8.SetIsRegisterPlusOffset(k_ebx, 8);
+  ebp_plus_0.SetIsRegisterPlusOffset(k_ebp, 0);
+
+  // Test CFA
+  EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
+  EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
+  for (size_t i = 3; i < 33; ++i)
+    EXPECT_EQ(ebx_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
+        << "i: " << i;
+  EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(33)->GetCFAValue());
+
+  // Test AFA
+  EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(12)->GetAFAValue());
+  EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(15)->GetAFAValue());
+  EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(16)->GetAFAValue());
+  for (size_t i = 18; i < 30; ++i)
+    EXPECT_EQ(ebp_plus_0, plan.GetRowForFunctionOffset(i)->GetAFAValue())
+        << "i: " << i;
+  EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(30)->GetAFAValue());
+
+  // Test saved register
+  UnwindPlan::Row::RegisterLocation reg_loc;
+  EXPECT_TRUE(
+      plan.GetRowForFunctionOffset(27)->GetRegisterInfo(k_edi, reg_loc));
+  EXPECT_TRUE(reg_loc.IsAtAFAPlusOffset());
+  EXPECT_EQ(-4, reg_loc.GetOffset());
+}
+
 // Give the disassembler random bytes to test that it doesn't exceed
 // the bounds of the array when run under clang's address sanitizer.
 TEST_F(Testx86AssemblyInspectionEngine, TestDisassemblyJunkBytes) {
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);
   std::unique_ptr<x86AssemblyInspectionEngine> engine32 = Geti386Inspector();
   std::unique_ptr<x86AssemblyInspectionEngine> engine64 = Getx86_64Inspector();