Auto advance pc for signle stepping on arm when emulation failes

[tberghammer]

Summary

Auto advance pc for single stepping on arm when emulation fails

The arm instruction emulation handles only some of the opcode (including
all of them modifying the PC). For the rest of the instructions we can
advance the PC by the size of the instruction as they don't modify the
PC on any other way.

[ovyalov]

LGTM

[omjavaid]

Some comments inline.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3691

Is this function name intentional? This seems to be a typo as correct register name is CPSR.

3728

Update function name here as well.

3734

This actually hides a genuine emulation failure.

May be we can add a check to verify that pc hasnt change before advancing it.

3737

Please correct ReadCpsr here as well.

[tberghammer]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3691

Fixed

3728

Done

3734

Added a check to report error if the emulation is failed after modifying PC (it should never happen on arm based on the current implementation). A proper solution would be to change the return value of EvaluateInstruction to report a proper error code. I will try to fix it sometime in the future.

3737

Done

source/Plugins/Process/Linux/NativeProcessLinux.cpp

WriteRegisterCallback (EmulateInstruction *instruction,
     case LLDB_REGNUM_GENERIC_FLAGS:
         emulator_baton->m_cpsr = reg_value;
         break;
     }
 
     return true;
 }
 
-static size_t WriteMemoryCallback (EmulateInstruction *instruction,
-                                   void *baton,
-                                   const EmulateInstruction::Context &context, 
-                                   lldb::addr_t addr, 
-                                   const void *dst,
-                                   size_t length)
+static size_t
+WriteMemoryCallback (EmulateInstruction *instruction,
 {
     return length;
 }
 
+static lldb::addr_t
+ReadCspr (NativeRegisterContext* regsiter_context)
+{
+    const RegisterInfo* cpsr_info = regsiter_context->GetRegisterInfo(
+            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+    return regsiter_context->ReadRegisterAsUnsigned(cpsr_info, LLDB_INVALID_ADDRESS);
+}
+
 Error
 NativeProcessLinux::SingleStep(lldb::tid_t tid, uint32_t signo)
 {
     Error error;
     NativeRegisterContextSP register_context_sp = GetThreadByID(tid)->GetRegisterContext();
 
     std::unique_ptr<EmulateInstruction> emulator_ap(
         EmulateInstruction::FindPlugin(m_arch, eInstructionTypePCModifying, nullptr));
 
     if (emulator_ap == nullptr)
-        return Error("Instrunction emulator not found!");
+        return Error("Instruction emulator not found!");
 
     EmulatorBaton baton(this, register_context_sp.get());
     emulator_ap->SetBaton(&baton);
     emulator_ap->SetReadMemCallback(&ReadMemoryCallback);
     emulator_ap->SetReadRegCallback(&ReadRegisterCallback);
     emulator_ap->SetWriteMemCallback(&WriteMemoryCallback);
     emulator_ap->SetWriteRegCallback(&WriteRegisterCallback);
 
     if (!emulator_ap->ReadInstruction())
         return Error("Read instruction failed!");
 
-    if (!emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC))
-        return Error("Evaluate instrcution failed!");
-
-    lldb::addr_t next_pc = baton.m_pc.GetAsUInt32();
-    lldb::addr_t next_cpsr = 0;
-    if (baton.m_cpsr.GetType() != RegisterValue::eTypeInvalid)
+    lldb::addr_t next_pc;
+    lldb::addr_t next_cpsr;
+    if (emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC))
     {
+        next_pc = baton.m_pc.GetAsUInt32();
+        if (baton.m_cpsr.GetType() != RegisterValue::eTypeInvalid)
             next_cpsr = baton.m_cpsr.GetAsUInt32();
+        else
+            next_cpsr = ReadCspr (register_context_sp.get());
     }
     else
     {
-        const RegisterInfo* cpsr_info = register_context_sp->GetRegisterInfo(
-            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
-        next_cpsr = register_context_sp->ReadRegisterAsUnsigned(cpsr_info, LLDB_INVALID_ADDRESS);
+        // Emulate instruction failed. Advance PC with the size of the current
+        // opcode because the emulation of all PC modifying instruction should
+        // be successful.
+        next_pc = register_context_sp->GetPC() + emulator_ap->GetOpcode().GetByteSize();
+        next_cpsr = ReadCspr (register_context_sp.get());
     }
 
     if (next_cpsr & 0x20)
     {
         // Thumb mode
         error = SetBreakpoint(next_pc, 2, false);
     }
     else
     {