Fix register read callback in linux-arm single stepping

[tberghammer]

Summary

Fix register read callback in linux-arm single stepping

The previous read callback always read the value of the register what
caused problems when the emulator wrote some value into a register and
then expected to read the same value back. This CL add a register value
cache into the callbacks to return the correct value after a register
write also.

[tberghammer]

Fix register number kind

[clayborg]

Looks good.

[labath]

Tamas is on holiday, so I have committed this on his behalf.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 }
 
 namespace {
 
 struct EmulatorBaton
 {
     NativeProcessLinux* m_process;
     NativeRegisterContext* m_reg_context;
-    RegisterValue m_pc;
-    RegisterValue m_flags;
+
+    // eRegisterKindDWARF -> RegsiterValue
+    std::unordered_map<uint32_t, RegisterValue> m_register_values;
 
-    EmulatorBaton(NativeProcessLinux* process, NativeRegisterContext* reg_context) : 
+    EmulatorBaton(NativeProcessLinux* process, NativeRegisterContext* reg_context) :
             m_process(process), m_reg_context(reg_context) {}
 };
 
 } // anonymous namespace
 
 static size_t
 ReadMemoryCallback (EmulateInstruction *instruction,
                     void *baton,

 static bool
 ReadRegisterCallback (EmulateInstruction *instruction,
                       void *baton,
                       const RegisterInfo *reg_info,
                       RegisterValue &reg_value)
 {
     EmulatorBaton* emulator_baton = static_cast<EmulatorBaton*>(baton);
 
+    auto it = emulator_baton->m_register_values.find(reg_info->kinds[eRegisterKindDWARF]);
+    if (it != emulator_baton->m_register_values.end())
+    {
+        reg_value = it->second;
+        return true;
+    }
+
     // The emulator only fill in the dwarf regsiter numbers (and in some case
     // the generic register numbers). Get the full register info from the
     // register context based on the dwarf register numbers.
     const RegisterInfo* full_reg_info = emulator_baton->m_reg_context->GetRegisterInfo(
             eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
 
     Error error = emulator_baton->m_reg_context->ReadRegister(full_reg_info, reg_value);
-    return error.Success();
+    if (error.Success())
+    {
+        emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] = reg_value;
+        return true;
+    }
+    return false;
 }
 
 static bool
 WriteRegisterCallback (EmulateInstruction *instruction,
                        void *baton,
                        const EmulateInstruction::Context &context,
                        const RegisterInfo *reg_info,
                        const RegisterValue &reg_value)
 {
     EmulatorBaton* emulator_baton = static_cast<EmulatorBaton*>(baton);
-
-    switch (reg_info->kinds[eRegisterKindGeneric])
-    {
-    case LLDB_REGNUM_GENERIC_PC:
-        emulator_baton->m_pc = reg_value;
-        break;
-    case LLDB_REGNUM_GENERIC_FLAGS:
-        emulator_baton->m_flags = reg_value;
-        break;
-    }
-
+    emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] = reg_value;
     return true;
 }
 
 static size_t
 WriteMemoryCallback (EmulateInstruction *instruction,
                      void *baton,
                      const EmulateInstruction::Context &context, 
                      lldb::addr_t addr, 
NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadProtocolSP thread_sp)
     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!");
 
+    bool emulation_result = emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
+
+    const RegisterInfo* reg_info_pc = register_context_sp->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+    const RegisterInfo* reg_info_flags = register_context_sp->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+
+    auto pc_it = baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
+    auto flags_it = baton.m_register_values.find(reg_info_flags->kinds[eRegisterKindDWARF]);
+
     lldb::addr_t next_pc;
     lldb::addr_t next_flags;
-    if (emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC))
+    if (emulation_result)
     {
-        next_pc = baton.m_pc.GetAsUInt64();
-        if (baton.m_flags.GetType() != RegisterValue::eTypeInvalid)
-            next_flags = baton.m_flags.GetAsUInt32();
+        assert(pc_it != baton.m_register_values.end() && "Emulation was successfull but PC wasn't updated");
+        next_pc = pc_it->second.GetAsUInt64();
+
+        if (flags_it != baton.m_register_values.end())
+            next_flags = flags_it->second.GetAsUInt64();
         else
             next_flags = ReadFlags (register_context_sp.get());
     }
-    else if (baton.m_pc.GetType() == RegisterValue::eTypeInvalid)
+    else if (pc_it == baton.m_register_values.end())
     {
         // Emulate instruction failed and it haven't changed PC. Advance PC
         // with the size of the current opcode because the emulation of all
         // PC modifying instruction should be successful. The failure most
         // likely caused by a not supported instruction which don't modify PC.
         next_pc = register_context_sp->GetPC() + emulator_ap->GetOpcode().GetByteSize();
         next_flags = ReadFlags (register_context_sp.get());
     }
if (m_arch.GetMachine() == llvm::Triple::arm)
         }
     }
     else
     {
         // No size hint is given for the next breakpoint
         error = SetSoftwareBreakpoint(next_pc, 0);
     }
 
-
     if (error.Fail())
         return error;
 
     m_threads_stepping_with_breakpoint.insert({thread_sp->GetID(), next_pc});
 
     return Error();
 }