[LLDB] Change pointer to ref in EmulateInstruction::ReadRegister methods

[DavidSpickett]

Summary

ReadRegister and ReadRegisterAsUnsigned are always passed valid pointers,
so the parameter should be a ref to make the intent clear.

[DavidSpickett]

ping!

[clayborg]

sorry for the delay, was on vacation for the past week

[DavidSpickett]

No problem, thanks for the reviews!

lldb/include/lldb/Core/EmulateInstruction.h

virtual bool SetInstruction(const Opcode &insn_opcode,
                               const Address &inst_addr, Target *target);
 
   virtual bool CreateFunctionEntryUnwind(UnwindPlan &unwind_plan);
 
   static const char *TranslateRegister(lldb::RegisterKind reg_kind,
                                        uint32_t reg_num, std::string &reg_name);
 
   // RegisterInfo variants
-  bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value);
+  bool ReadRegister(const RegisterInfo &reg_info, RegisterValue &reg_value);
 
-  uint64_t ReadRegisterUnsigned(const RegisterInfo *reg_info,
+  uint64_t ReadRegisterUnsigned(const RegisterInfo &reg_info,
                                 uint64_t fail_value, bool *success_ptr);
 
   bool WriteRegister(const Context &context, const RegisterInfo *ref_info,
                      const RegisterValue &reg_value);
 
   bool WriteRegisterUnsigned(const Context &context,
                              const RegisterInfo *reg_info, uint64_t reg_value);
 

lldb/source/Core/EmulateInstruction.cpp

for (uint32_t idx = 0;
         return emulate_insn_ptr;
     }
   }
   return nullptr;
 }
 
 EmulateInstruction::EmulateInstruction(const ArchSpec &arch) : m_arch(arch) {}
 
-bool EmulateInstruction::ReadRegister(const RegisterInfo *reg_info,
+bool EmulateInstruction::ReadRegister(const RegisterInfo &reg_info,
                                       RegisterValue &reg_value) {
   if (m_read_reg_callback != nullptr)
-    return m_read_reg_callback(this, m_baton, reg_info, reg_value);
+    return m_read_reg_callback(this, m_baton, &reg_info, reg_value);
   return false;
 }
 
 bool EmulateInstruction::ReadRegister(lldb::RegisterKind reg_kind,
                                       uint32_t reg_num,
                                       RegisterValue &reg_value) {
   llvm::Optional<RegisterInfo> reg_info = GetRegisterInfo(reg_kind, reg_num);
   if (reg_info)
-    return ReadRegister(&(*reg_info), reg_value);
+    return ReadRegister(*reg_info, reg_value);
   return false;
 }
 
 uint64_t EmulateInstruction::ReadRegisterUnsigned(lldb::RegisterKind reg_kind,
                                                   uint32_t reg_num,
                                                   uint64_t fail_value,
                                                   bool *success_ptr) {
   RegisterValue reg_value;
   if (ReadRegister(reg_kind, reg_num, reg_value))
     return reg_value.GetAsUInt64(fail_value, success_ptr);
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
-uint64_t EmulateInstruction::ReadRegisterUnsigned(const RegisterInfo *reg_info,
+uint64_t EmulateInstruction::ReadRegisterUnsigned(const RegisterInfo &reg_info,
                                                   uint64_t fail_value,
                                                   bool *success_ptr) {
   RegisterValue reg_value;
   if (ReadRegister(reg_info, reg_value))
     return reg_value.GetAsUInt64(fail_value, success_ptr);
   if (success_ptr)
     *success_ptr = false;
   return fail_value;

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

if (ConditionPassed(opcode)) {
 
     llvm::Optional<RegisterInfo> sp_reg =
         GetRegisterInfo(eRegisterKindDWARF, dwarf_sp);
     for (i = 0; i < regs; ++i) {
       llvm::Optional<RegisterInfo> dwarf_reg =
           GetRegisterInfo(eRegisterKindDWARF, start_reg + d + i);
       context.SetRegisterToRegisterPlusOffset(*dwarf_reg, *sp_reg, addr - sp);
       // uint64_t to accommodate 64-bit registers.
-      uint64_t reg_value = ReadRegisterUnsigned(&(*dwarf_reg), 0, &success);
+      uint64_t reg_value = ReadRegisterUnsigned(*dwarf_reg, 0, &success);
       if (!success)
         return false;
       if (!MemAWrite(context, addr, reg_value, reg_byte_size))
         return false;
       addr += reg_byte_size;
     }
 
     context.type = EmulateInstruction::eContextAdjustStackPointer;

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

case MemOp_STORE: {
     } 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))
+    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))
       return false;
 
-    if (!ReadRegister(&(*reg_info_Rt2), data_Rt2))
+    if (!ReadRegister(*reg_info_Rt2, data_Rt2))
       return false;
 
     if (data_Rt2.GetAsMemoryData(&(*reg_info_Rt2), buffer,
                                  reg_info_Rt2->byte_size, eByteOrderLittle,
                                  error) == 0)
       return false;
 
     if (!WriteMemory(context_t2, address + size, buffer,
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))
+    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;

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

if (nonvolatile_reg_p(src)) {
     Context context;
     RegisterValue data_src;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
-    if (!ReadRegister(&(*reg_info_base), data_src))
+    if (!ReadRegister(*reg_info_base, data_src))
       return false;
 
     if (data_src.GetAsMemoryData(&(*reg_info_src), buffer,
                                  reg_info_src->byte_size, eByteOrderLittle,
                                  error) == 0)
       return false;
 
     if (!WriteMemory(context, address, buffer, reg_info_src->byte_size))
if (base == dwarf_sp_mips && nonvolatile_reg_p(src)) {
     Context context;
     RegisterValue data_src;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
-    if (!ReadRegister(&(*reg_info_base), data_src))
+    if (!ReadRegister(*reg_info_base, data_src))
       return false;
 
     if (data_src.GetAsMemoryData(&reg_info_src, buffer, reg_info_src.byte_size,
                                  eByteOrderLittle, error) == 0)
       return false;
 
     if (!WriteMemory(context, address, buffer, reg_info_src.byte_size))
       return false;
for (uint32_t i = 0; i < num_operands - 2; i++) {
     Context context;
     RegisterValue data_src;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
-    if (!ReadRegister(&(*reg_info_base), data_src))
+    if (!ReadRegister(*reg_info_base, data_src))
       return false;
 
     if (data_src.GetAsMemoryData(&(*reg_info_src), buffer,
                                  reg_info_src->byte_size, eByteOrderLittle,
                                  error) == 0)
       return false;
 
     if (!WriteMemory(context, base_address, buffer, reg_info_src->byte_size))

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

if (nonvolatile_reg_p(src)) {
     Context context;
     RegisterValue data_src;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
-    if (!ReadRegister(&(*reg_info_base), data_src))
+    if (!ReadRegister(*reg_info_base, data_src))
       return false;
 
     if (data_src.GetAsMemoryData(&(*reg_info_src), buffer,
                                  reg_info_src->byte_size, eByteOrderLittle,
                                  error) == 0)
       return false;
 
     if (!WriteMemory(context, address, buffer, reg_info_src->byte_size))