Improve instruction emulation based stack unwinding

[tberghammer]

Summary

Improve instruction emulation based stack unwinding

On ARM there is no difference between a pop and a load instruction so
a register can be loaded multiple times during the function. Add check
to threat the load as a restore only if it do the restore from the
same location where the register was saved.

[tberghammer]

Fix incorrect assert

[jasonmolenda]

Looks good to me.

[chying]

It seems a bunch of darwin->android_arm tests are broken after this patch.
Could you take a look?
Here is the first build after this patch.
http://lab.llvm.org:8011/builders/lldb-x86_64-darwin-13.4/builds/4977/steps/test7/logs/stdio

[tberghammer]

Fixed by rL245690

source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

if (ConditionPassed(opcode))
         
         RegisterInfo sp_reg;
         GetRegisterInfo (eRegisterKindDWARF, dwarf_sp, sp_reg);
 
         for (i=0; i<15; ++i)
         {
             if (BitIsSet (registers, i))
             {
-                context.SetRegisterPlusOffset (sp_reg, addr - sp);
+                context.SetAddress(addr);
                 data = MemARead(context, addr, 4, 0, &success);
                 if (!success)
                     return false;    
                 if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + i, data))
                     return false;
                 addr += addr_byte_size;
             }
         }
if (ConditionPassed(opcode))
         context.type = EmulateInstruction::eContextPopRegisterOffStack;
 
         RegisterInfo dwarf_reg;
         RegisterInfo sp_reg;
         GetRegisterInfo (eRegisterKindDWARF, dwarf_sp, sp_reg);
         for (i=0; i<regs; ++i)
         {
             GetRegisterInfo (eRegisterKindDWARF, start_reg + d + i, dwarf_reg);
-            context.SetRegisterPlusOffset (sp_reg, addr - sp);
+            context.SetAddress(addr);
             data = MemARead(context, addr, reg_byte_size, 0, &success);
             if (!success)
                 return false;    
             if (!WriteRegisterUnsigned(context, &dwarf_reg, data))
                 return false;
             addr += reg_byte_size;
         }
         
if (ConditionPassed(opcode))
                   
         for (int i = 0; i < 14; ++i)
         {
             if (BitIsSet (registers, i))
             {
                 context.type = EmulateInstruction::eContextRegisterPlusOffset;
                 context.SetRegisterPlusOffset (dwarf_reg, offset);
                 if (wback && (n == 13)) // Pop Instruction
+                {
                     context.type = EmulateInstruction::eContextPopRegisterOffStack;
+                    context.SetAddress(base_address + offset);
+                }
 
                 // R[i] = MemA [address, 4]; address = address + 4;
                 uint32_t data = MemARead (context, base_address + offset, addr_byte_size, 0, &success);
                 if (!success)
                     return false;
                   
                 if (!WriteRegisterUnsigned (context, eRegisterKindDWARF, dwarf_r0 + i, data))
                     return false;
if (ConditionPassed(opcode))
         RegisterInfo base_reg;
         GetRegisterInfo (eRegisterKindDWARF, dwarf_r0 + n, base_reg);
                   
         EmulateInstruction::Context context;
         if (n == 13)
             context.type = eContextPopRegisterOffStack;
         else
             context.type = eContextRegisterLoad;
-        context.SetRegisterPlusOffset (base_reg, address - Rn);
+        context.SetAddress(address);
                   
         const uint32_t addr_byte_size = GetAddressByteSize();
         uint32_t data = MemARead (context, address, addr_byte_size, 0, &success);
         if (!success)
             return false;
                   
         if (!WriteRegisterUnsigned (context, eRegisterKindDWARF, dwarf_r0 + t, data))
             return false;
if (ConditionPassed(opcode))
         else
             address = Rn;
                   
         EmulateInstruction::Context context;
         if (n == 13)
             context.type = eContextPopRegisterOffStack;
         else
             context.type = eContextRegisterLoad;
-        context.SetRegisterPlusIndirectOffset (base_reg, offset_reg);
+        context.SetAddress(address);
                   
         // R[t] = MemA[address,4];
         const uint32_t addr_byte_size = GetAddressByteSize();
         uint32_t data = MemARead (context, address, addr_byte_size, 0, &success);
         if (!success)
             return false;
                   
         if (!WriteRegisterUnsigned (context, eRegisterKindDWARF, dwarf_r0 + t, data))

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

EmulateInstructionARM64::EmulateLDPSTP (const uint32_t opcode)
     
     wb_address = address + idx;
     if (a_mode != AddrMode_POST)
         address = wb_address;
     
     Context context_t;
     Context context_t2;
 
-    context_t.SetRegisterToRegisterPlusOffset (reg_info_Rt, reg_info_base, 0);
-    context_t2.SetRegisterToRegisterPlusOffset (reg_info_Rt2, reg_info_base, size);
     uint8_t buffer [RegisterValue::kMaxRegisterByteSize];
     Error error;
 
     switch (memop)
     {
         case MemOp_STORE:
         {
             if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is based off of the sp or fp register
             {
                 context_t.type = eContextPushRegisterOnStack;
                 context_t2.type = eContextPushRegisterOnStack;
             }
             else
             {
                 context_t.type = eContextRegisterStore;
                 context_t2.type = eContextRegisterStore;
             }
+            context_t.SetRegisterToRegisterPlusOffset (reg_info_Rt, reg_info_base, 0);
+            context_t2.SetRegisterToRegisterPlusOffset (reg_info_Rt2, reg_info_base, size);
 
             if (!ReadRegister (&reg_info_Rt, data_Rt))
                 return false;
             
             if (data_Rt.GetAsMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size, eByteOrderLittle, error) == 0)
                 return false;
             
             if (!WriteMemory(context_t, address + 0, buffer, reg_info_Rt.byte_size))
switch (memop)
                 context_t.type = eContextPopRegisterOffStack;
                 context_t2.type = eContextPopRegisterOffStack;
             }
             else
             {
                 context_t.type = eContextRegisterLoad;
                 context_t2.type = eContextRegisterLoad;
             }
+            context_t.SetAddress(address);
+            context_t2.SetAddress(address + size);
 
             if (rt_unknown)
                 memset (buffer, 'U', reg_info_Rt.byte_size);
             else
             {
                 if (!ReadMemory (context_t, address, buffer, reg_info_Rt.byte_size))
                     return false;
             }
EmulateInstructionARM64::EmulateLDRSTRImm (const uint32_t opcode)
     if (!GetRegisterInfo (eRegisterKindDWARF, arm64_dwarf::x0 + n, reg_info_base))
         return false;
 
     RegisterInfo reg_info_Rt;
     if (!GetRegisterInfo (eRegisterKindDWARF, arm64_dwarf::x0 + t, reg_info_Rt))
         return false;
 
     Context context;
-    context.SetRegisterToRegisterPlusOffset (reg_info_Rt, reg_info_base, postindex ? 0 : offset);
-
     switch (memop)
     {
         case MemOp_STORE:
             if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is based off of the sp or fp register
                 context.type = eContextPushRegisterOnStack;
             else
                 context.type = eContextRegisterStore;
+            context.SetRegisterToRegisterPlusOffset (reg_info_Rt, reg_info_base, postindex ? 0 : offset);
 
             if (!ReadRegister (&reg_info_Rt, data_Rt))
                 return false;
             
             if (data_Rt.GetAsMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size, eByteOrderLittle, error) == 0)
                 return false;
 
             if (!WriteMemory(context, address, buffer, reg_info_Rt.byte_size))
                 return false;
             break;
             
         case MemOp_LOAD:
             if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is based off of the sp or fp register
                 context.type = eContextPopRegisterOffStack;
             else
                 context.type = eContextRegisterLoad;
+            context.SetAddress(address);
 
             if (!ReadMemory (context, address, buffer, reg_info_Rt.byte_size))
                 return false;
 
             if (data_Rt.SetFromMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size, eByteOrderLittle, error) == 0)
                 return false;
 
             if (!WriteRegister (context, &reg_info_Rt, data_Rt))

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

//            }
         case EmulateInstruction::eContextPopRegisterOffStack:
             {
                 if (!instruction->IsInstructionConditional())
                 {
                     const uint32_t reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
                     const uint32_t generic_regnum = reg_info->kinds[eRegisterKindGeneric];
                     if (reg_num != LLDB_INVALID_REGNUM && generic_regnum != LLDB_REGNUM_GENERIC_SP)
                     {
+                        if (context.info_type == EmulateInstruction::eInfoTypeAddress)
+                        {
+                            if (m_pushed_regs.find (reg_num) != m_pushed_regs.end () &&
+                                context.info.address == m_pushed_regs[reg_num])
+                            {
                                 m_curr_row->SetRegisterLocationToSame (reg_num, /*must_replace*/ false);
                                 m_curr_row_modified = true;
                             }
                         }
+                        else
+                            assert (!"unhandled case, add code to handle this!");
+                    }
+                }
             }
             break;
 
         case EmulateInstruction::eContextSetFramePointer:
             if (!m_fp_is_cfa && !instruction->IsInstructionConditional())
             {
                 m_fp_is_cfa = true;
                 m_cfa_reg_info = *reg_info;