[lldb][ARM] Print mismatched registers in emulation tests

[DavidSpickett]

Summary

Also correct the test failed message. It implies that what
it's done is compare the 'before' and 'ater' states from the
test input.

Except that that's the whole point of the test, that the state changes.
It should tell you that it compared the result of the emulation to the
'after'.

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

SetCallbacks(&EmulationStateARM::ReadPseudoMemory,
                &EmulationStateARM::WritePseudoRegister);
 
   bool success = EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
   if (!success) {
     out_stream->Printf("TestEmulation:  EvaluateInstruction() failed.\n");
     return false;
   }
 
-  success = before_state.CompareState(after_state);
+  success = before_state.CompareState(after_state, out_stream);
   if (!success)
     out_stream->Printf(
-        "TestEmulation:  'before' and 'after' states do not match.\n");
+        "TestEmulation:  State after emulation does not match 'after' state.\n");
 
   return success;
 }
 //
 //
 // const char *
 // EmulateInstructionARM::GetRegisterName (uint32_t reg_kind, uint32_t reg_num)
 //{

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h

public:
   void ClearPseudoRegisters();
 
   void ClearPseudoMemory();
 
   bool LoadPseudoRegistersFromFrame(lldb_private::StackFrame &frame);
 
   bool LoadStateFromDictionary(lldb_private::OptionValueDictionary *test_data);
 
-  bool CompareState(EmulationStateARM &other_state);
+  bool CompareState(EmulationStateARM &other_state,
+                    lldb_private::Stream *out_stream);
 
   static size_t
   ReadPseudoMemory(lldb_private::EmulateInstruction *instruction, void *baton,
                    const lldb_private::EmulateInstruction::Context &context,
                    lldb::addr_t addr, void *dst, size_t length);
 
   static size_t
   WritePseudoMemory(lldb_private::EmulateInstruction *instruction, void *baton,

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

bool EmulationStateARM::WritePseudoRegister(
 
   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
   const uint32_t dwarf_reg_num = reg_info->kinds[eRegisterKindDWARF];
   assert(dwarf_reg_num != LLDB_INVALID_REGNUM);
   return pseudo_state->StorePseudoRegisterValue(dwarf_reg_num,
                                                 reg_value.GetAsUInt64());
 }
 
-bool EmulationStateARM::CompareState(EmulationStateARM &other_state) {
+bool EmulationStateARM::CompareState(EmulationStateARM &other_state,
+                                     Stream *out_stream) {
   bool match = true;
 
   for (int i = 0; match && i < 17; ++i) {
-    if (m_gpr[i] != other_state.m_gpr[i])
+    if (m_gpr[i] != other_state.m_gpr[i]) {
       match = false;
+      out_stream->Printf("r%d: 0x%x != 0x%x\n", i, m_gpr[i],
+                         other_state.m_gpr[i]);
+    }
   }
 
   for (int i = 0; match && i < 32; ++i) {
-    if (m_vfp_regs.s_regs[i] != other_state.m_vfp_regs.s_regs[i])
+    if (m_vfp_regs.s_regs[i] != other_state.m_vfp_regs.s_regs[i]) {
       match = false;
+      out_stream->Printf("s%d: 0x%x != 0x%x\n", i, m_vfp_regs.s_regs[i],
+                         other_state.m_vfp_regs.s_regs[i]);
+    }
   }
 
   for (int i = 0; match && i < 16; ++i) {
-    if (m_vfp_regs.d_regs[i] != other_state.m_vfp_regs.d_regs[i])
+    if (m_vfp_regs.d_regs[i] != other_state.m_vfp_regs.d_regs[i]) {
       match = false;
+      out_stream->Printf("d%d: 0x%lx != 0x%lx\n", i + 16, m_vfp_regs.d_regs[i],
+                         other_state.m_vfp_regs.d_regs[i]);
+    }
   }
 
   return match;
 }
 
 bool EmulationStateARM::LoadRegistersStateFromDictionary(
     OptionValueDictionary *reg_dict, char kind, int first_reg, int num) {
   StreamString sstr;