Add support for 'leal' instruction to UnwindAssembly-x86

[tberghammer]

Summary

Add support for 'leal' instruction to UnwindAssembly-x86

Gcc for android use the leal instruction to subtract from the stack pointer in the prologue of a function call. This patch add basic support for evaluating this instruction to support stack unwinding on android-x86.

[tberghammer]

Fix typo

[jasonmolenda]

Looks good, thanks for adding this, please commit. In the comments in lea_rsp_pattern_p() did you mean to write '8 bit' and '32 bit' displacement?

[tberghammer]

Thanks for catching the typos.

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

private:
     enum { kMaxInstructionByteSize = 32 };
 
     bool nonvolatile_reg_p (int machine_regno);
     bool push_rbp_pattern_p ();
     bool push_0_pattern_p ();
     bool mov_rsp_rbp_pattern_p ();
     bool sub_rsp_pattern_p (int& amount);
     bool add_rsp_pattern_p (int& amount);
+    bool lea_rsp_pattern_p (int& amount);
     bool push_reg_p (int& regno);
     bool pop_reg_p (int& regno);
     bool push_imm_pattern_p ();
     bool mov_reg_to_local_stack_frame_p (int& regno, int& fp_offset);
     bool ret_pattern_p ();
     bool pop_rbp_pattern_p ();
     bool call_next_insn_pattern_p();
     uint32_t extract_4 (uint8_t *b);
AssemblyParse_x86::add_rsp_pattern_p (int& amount)
     if (*p == 0x81 && *(p + 1) == 0xc4)
     {
         amount = (int32_t) extract_4 (p + 2);
         return true;
     }
     return false;
 }
 
+// lea esp, [esp - 0x28]
+// lea esp, [esp + 0x28]
+bool
+AssemblyParse_x86::lea_rsp_pattern_p (int& amount)
+{
+    uint8_t *p = m_cur_insn_bytes;
+    if (m_wordsize == 8 && *p == 0x48)
+        p++;
+
+    // Check opcode
+    if (*p != 0x8d)
+        return false;
+
+    // 8 bit displacement
+    if (*(p + 1) == 0x64 && (*(p + 2) & 0x3f) == 0x24)
+    {
+        amount = (int8_t) *(p + 3);
+        return true;
+    }
+
+    // 32 bit displacement
+    if (*(p + 1) == 0xa4 && (*(p + 2) & 0x3f) == 0x24)
+    {
+        amount = (int32_t) extract_4 (p + 3);
+        return true;
+    }
+
+    return false;
+}
+
 // pushq %rbx
 // pushl %ebx
 bool 
 AssemblyParse_x86::push_reg_p (int& regno)
 {
     uint8_t *p = m_cur_insn_bytes;
     int regno_prefix_bit = 0;
     // If we have a rex prefix byte, check to see if a B bit is set
while (m_func_bounds.ContainsFileAddress (m_cur_insn))
             if (row->GetCFAValue().GetRegisterNumber() == m_lldb_sp_regnum)
             {
                 row->GetCFAValue().SetOffset (current_sp_bytes_offset_from_cfa);
                 row_updated = true;
             }
             in_epilogue = 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);
+                row_updated = true;
+            }
+            if (stack_offset > 0)
+                in_epilogue = true;
+        }
+
         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);
while (func.ContainsFileAddress (m_cur_insn))
                 row->SetOffset (offset);
                 row->GetCFAValue().IncOffset (amount);
 
                 UnwindPlan::RowSP new_row(new UnwindPlan::Row(*row));
                 unwind_plan.InsertRow (new_row);
                 unwind_plan_updated = true;
                 continue;
             }
+
+            // lea %rsp, [%rsp + $offset]
+            if (lea_rsp_pattern_p (amount))
+            {
+                row->SetOffset (offset);
+                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 ())
             {
                 reinstate_unwind_state = true;
                 continue;
             }
         }
         else if (cfa_reg == m_lldb_fp_regnum)
         {
while (m_func_bounds.ContainsFileAddress (m_cur_insn))
         if (target->ReadMemory (m_cur_insn, prefer_file_cache, m_cur_insn_bytes,
                                 insn_len, error) == static_cast<size_t>(-1))
         {
            // Error reading the instruction out of the file, stop scanning
            break;
         }
 
         if (push_rbp_pattern_p () || mov_rsp_rbp_pattern_p () || sub_rsp_pattern_p (offset)
-            || push_reg_p (regno) || mov_reg_to_local_stack_frame_p (regno, offset))
+            || push_reg_p (regno) || mov_reg_to_local_stack_frame_p (regno, offset)
+            || (lea_rsp_pattern_p (offset) && offset < 0))
         {
             m_cur_insn.SetOffset (m_cur_insn.GetOffset() + insn_len);
             continue;
         }
 
         // Unknown non-prologue instruction - stop scanning
         break;
     }