[LLDB] Change RegisterValue::SetType param to const RegisterInfo&

[DavidSpickett]

Summary

No one was pasing nullptr here.

Depends on D135670

lldb/include/lldb/Utility/RegisterValue.h

public:
   }
 
   RegisterValue::Type GetType() const { return m_type; }
 
   bool CopyValue(const RegisterValue &rhs);
 
   void SetType(RegisterValue::Type type) { m_type = type; }
 
-  RegisterValue::Type SetType(const RegisterInfo *reg_info);
+  RegisterValue::Type SetType(const RegisterInfo &reg_info);
 
   bool GetData(DataExtractor &data) const;
 
   // Copy the register value from this object into a buffer in "dst" and obey
   // the "dst_byte_order" when copying the data. Also watch out in case
   // "dst_len" is longer or shorter than the register value described by
   // "reg_info" and only copy the least significant bytes of the register
   // value, or pad the destination with zeroes if the register byte size is

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

if (error.Success() && dest_size) {
       // Get the bytes for the source data.
       const uint32_t src_size = reg_value.GetAsMemoryData(
           *reg_info, src, sizeof(src), byte_order, error);
       if (error.Success() && src_size && (src_size < dest_size)) {
         // Copy the src bytes to the destination.
         memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
         // Set this full register as the value to write.
         value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-        value_to_write.SetType(full_reg_info);
+        value_to_write.SetType(*full_reg_info);
         reg_to_write = full_reg;
       }
     }
   }
 
   const RegisterInfo *const register_to_write_info_p =
       GetRegisterInfoAtIndex(reg_to_write);
   assert(register_to_write_info_p &&

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

if (error.Success()) {
       // value one byte to the right.
       if (is_subreg && (reg_info->byte_offset & 0x1))
         reg_value.SetUInt64(reg_value.GetAsUInt64() >> 8);
 
       // If our return byte size was greater than the return value reg size,
       // then use the type specified by reg_info rather than the uint64_t
       // default
       if (reg_value.GetByteSize() > reg_info->byte_size)
-        reg_value.SetType(reg_info);
+        reg_value.SetType(*reg_info);
     }
     return error;
   }
 
   // Get pointer to m_fpr variable and set the data from it.
   uint32_t fpr_offset = CalculateFprOffset(reg_info);
   assert(fpr_offset < sizeof m_fpr);
   uint8_t *src = (uint8_t *)&m_fpr + fpr_offset;

lldb/source/Utility/RegisterValue.cpp

case eTypeLongDouble:
     scalar = m_scalar;
     return true;
   }
   return false;
 }
 
 void RegisterValue::Clear() { m_type = eTypeInvalid; }
 
-RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
-  assert(reg_info && "Expected non null reg_info.");
+RegisterValue::Type RegisterValue::SetType(const RegisterInfo &reg_info) {
   // To change the type, we simply copy the data in again, using the new format
   RegisterValue copy;
   DataExtractor copy_data;
   if (copy.CopyValue(*this) && copy.GetData(copy_data)) {
-    Status error = SetValueFromData(*reg_info, copy_data, 0, true);
+    Status error = SetValueFromData(reg_info, copy_data, 0, true);
     assert(error.Success() && "Expected SetValueFromData to succeed.");
     UNUSED_IF_ASSERT_DISABLED(error);
   }
 
   return m_type;
 }
 
 Status RegisterValue::SetValueFromData(const RegisterInfo &reg_info,