[LLDB] Change RegisterValue::GetAsMemoryData to const RegisterInfo&

[DavidSpickett]

Summary

Most of the paths to this never passed nullptr intentionally. Those
that possibly could have were assuming it was not null elsehwere,
so would have crashed.

I've added asserts in those cases.

At least one case was relying on GetAsMemoryData to return an error
when it was given nullptr. So I've hoisted that error setting code
out into the caller.

Depends on D134963

[DavidSpickett]

ping!

lldb/include/lldb/Utility/RegisterValue.h

public:
 
   // 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
   // shorter that "dst_len" (all while correctly abiding the "dst_byte_order").
   // Returns the number of bytes copied into "dst".
-  uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
+  uint32_t GetAsMemoryData(const RegisterInfo &reg_info, void *dst,
                            uint32_t dst_len, lldb::ByteOrder dst_byte_order,
                            Status &error) const;
 
   uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src,
                              uint32_t src_len, lldb::ByteOrder src_byte_order,
                              Status &error);
 
   bool GetScalarValue(Scalar &scalar) const;

lldb/source/Host/common/NativeRegisterContext.cpp

reg_value.SetFromMemoryData(reg_info, src, src_len, process.GetByteOrder(),
                               error);
 
   return error;
 }
 
 Status NativeRegisterContext::WriteRegisterValueToMemory(
     const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len,
     const RegisterValue &reg_value) {
-
-  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
   Status error;
+  if (reg_info == nullptr) {
+    error.SetErrorString("Invalid register info argument.");
+    return error;
+  }
 
+  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
   NativeProcessProtocol &process = m_thread.GetProcess();
 
   // TODO: we might need to add a parameter to this function in case the byte
   // order of the memory data doesn't match the process. For now we are
   // assuming they are the same.
   const size_t bytes_copied = reg_value.GetAsMemoryData(
-      reg_info, dst, dst_len, process.GetByteOrder(), error);
+      *reg_info, dst, dst_len, process.GetByteOrder(), error);
 
   if (error.Success()) {
     if (bytes_copied == 0) {
       error.SetErrorString("byte copy failed.");
     } else {
       size_t bytes_written;
       error = process.WriteMemory(dst_addr, dst, bytes_copied, bytes_written);
       if (error.Fail())

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp

if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
         RegisterValue reg_value;
 
         if (!reg_ctx->ReadRegister(reg_info, reg_value))
           return false;
 
         // Make sure we have enough room in "heap_data_up"
         if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
           const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
-              byte_order, error);
+              *reg_info, heap_data_up->GetBytes() + data_offset,
+              *base_byte_size, byte_order, error);
           if (bytes_copied != *base_byte_size)
             return false;
           data_offset += bytes_copied;
           ++NSRN;
         } else
           return false;
       }
       data.SetByteOrder(byte_order);
while (data_offset < *byte_size) {
 
       RegisterValue reg_value;
 
       if (!reg_ctx->ReadRegister(reg_info, reg_value))
         return false;
 
       const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
       const size_t bytes_copied = reg_value.GetAsMemoryData(
-          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
+          *reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
           byte_order, error);
       if (bytes_copied == 0)
         return false;
       if (bytes_copied >= bytes_left)
         break;
       data_offset += bytes_copied;
       bytes_left -= bytes_copied;
       ++NGRN;
if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
                   const ByteOrder byte_order =
                       exe_ctx.GetProcessRef().GetByteOrder();
                   RegisterValue x0_reg_value;
                   RegisterValue x1_reg_value;
                   if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
                       reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
                     Status error;
                     if (x0_reg_value.GetAsMemoryData(
-                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
+                            *x0_reg_info, heap_data_up->GetBytes() + 0, 8,
                             byte_order, error) &&
                         x1_reg_value.GetAsMemoryData(
-                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
+                            *x1_reg_info, heap_data_up->GetBytes() + 8, 8,
                             byte_order, error)) {
                       DataExtractor data(
                           DataBufferSP(heap_data_up.release()), byte_order,
                           exe_ctx.GetProcessRef().GetAddressByteSize());
 
                       return_valobj_sp = ValueObjectConstResult::Create(
                           &thread, return_compiler_type, ConstString(""), data);
                       return return_valobj_sp;
if (*byte_size > 0) {
       if (v0_info) {
         if (*byte_size <= v0_info->byte_size) {
           std::unique_ptr<DataBufferHeap> heap_data_up(
               new DataBufferHeap(*byte_size, 0));
           const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
           RegisterValue reg_value;
           if (reg_ctx->ReadRegister(v0_info, reg_value)) {
             Status error;
-            if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
+            if (reg_value.GetAsMemoryData(*v0_info, heap_data_up->GetBytes(),
                                           heap_data_up->GetByteSize(),
                                           byte_order, error)) {
               DataExtractor data(DataBufferSP(heap_data_up.release()),
                                  byte_order,
                                  exe_ctx.GetProcessRef().GetAddressByteSize());
               return_valobj_sp = ValueObjectConstResult::Create(
                   &thread, return_compiler_type, ConstString(""), data);
             }

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp

if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
         RegisterValue reg_value;
 
         if (!reg_ctx->ReadRegister(reg_info, reg_value))
           return false;
 
         // Make sure we have enough room in "heap_data_up"
         if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
           const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
-              byte_order, error);
+              *reg_info, heap_data_up->GetBytes() + data_offset,
+              *base_byte_size, byte_order, error);
           if (bytes_copied != *base_byte_size)
             return false;
           data_offset += bytes_copied;
           ++NSRN;
         } else
           return false;
       }
       data.SetByteOrder(byte_order);
while (data_offset < *byte_size) {
 
       RegisterValue reg_value;
 
       if (!reg_ctx->ReadRegister(reg_info, reg_value))
         return false;
 
       const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
       const size_t bytes_copied = reg_value.GetAsMemoryData(
-          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
+          *reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
           byte_order, error);
       if (bytes_copied == 0)
         return false;
       if (bytes_copied >= bytes_left)
         break;
       data_offset += bytes_copied;
       bytes_left -= bytes_copied;
       ++NGRN;
if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
                   const ByteOrder byte_order =
                       exe_ctx.GetProcessRef().GetByteOrder();
                   RegisterValue x0_reg_value;
                   RegisterValue x1_reg_value;
                   if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
                       reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
                     Status error;
                     if (x0_reg_value.GetAsMemoryData(
-                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
+                            *x0_reg_info, heap_data_up->GetBytes() + 0, 8,
                             byte_order, error) &&
                         x1_reg_value.GetAsMemoryData(
-                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
+                            *x1_reg_info, heap_data_up->GetBytes() + 8, 8,
                             byte_order, error)) {
                       DataExtractor data(
                           DataBufferSP(heap_data_up.release()), byte_order,
                           exe_ctx.GetProcessRef().GetAddressByteSize());
 
                       return_valobj_sp = ValueObjectConstResult::Create(
                           &thread, return_compiler_type, ConstString(""), data);
                       return return_valobj_sp;
if (*byte_size > 0) {
 
       if (v0_info) {
         std::unique_ptr<DataBufferHeap> heap_data_up(
             new DataBufferHeap(*byte_size, 0));
         const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
         RegisterValue reg_value;
         if (reg_ctx->ReadRegister(v0_info, reg_value)) {
           Status error;
-          if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
+          if (reg_value.GetAsMemoryData(*v0_info, heap_data_up->GetBytes(),
                                         heap_data_up->GetByteSize(), byte_order,
                                         error)) {
             DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order,
                                exe_ctx.GetProcessRef().GetAddressByteSize());
             return_valobj_sp = ValueObjectConstResult::Create(
                 &thread, return_compiler_type, ConstString(""), data);
           }
         }

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

case 128:
               RegisterValue r1_reg_value;
               RegisterValue r2_reg_value;
               RegisterValue r3_reg_value;
               if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
                   reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
                   reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
                   reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
                 Status error;
-                if (r0_reg_value.GetAsMemoryData(r0_reg_info,
+                if (r0_reg_value.GetAsMemoryData(*r0_reg_info,
                                                  heap_data_up->GetBytes() + 0,
                                                  4, byte_order, error) &&
-                    r1_reg_value.GetAsMemoryData(r1_reg_info,
+                    r1_reg_value.GetAsMemoryData(*r1_reg_info,
                                                  heap_data_up->GetBytes() + 4,
                                                  4, byte_order, error) &&
-                    r2_reg_value.GetAsMemoryData(r2_reg_info,
+                    r2_reg_value.GetAsMemoryData(*r2_reg_info,
                                                  heap_data_up->GetBytes() + 8,
                                                  4, byte_order, error) &&
-                    r3_reg_value.GetAsMemoryData(r3_reg_info,
+                    r3_reg_value.GetAsMemoryData(*r3_reg_info,
                                                  heap_data_up->GetBytes() + 12,
                                                  4, byte_order, error)) {
                   DataExtractor data(DataBufferSP(heap_data_up.release()),
                                      byte_order,
                                      process_sp->GetAddressByteSize());
 
                   return_valobj_sp = ValueObjectConstResult::Create(
                       &thread, compiler_type, ConstString(""), data);

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

for (uint32_t reg_index = 0; reg_index < vfp_count; reg_index++) {
       RegisterValue reg_value;
       if (!reg_ctx->ReadRegister(reg_info, reg_value))
         break;
 
       // Make sure we have enough room in "data_sp"
       if ((data_offset + vfp_byte_size) <= data_sp->GetByteSize()) {
         Status error;
         const size_t bytes_copied = reg_value.GetAsMemoryData(
-            reg_info, data_sp->GetBytes() + data_offset, vfp_byte_size,
+            *reg_info, data_sp->GetBytes() + data_offset, vfp_byte_size,
             byte_order, error);
         if (bytes_copied != vfp_byte_size)
           break;
 
         data_offset += bytes_copied;
       }
     }
 

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

ValueObjectSP ABISysV_mips64::GetReturnValueObjectImpl(
   if (!byte_size)
     return return_valobj_sp;
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   uint32_t fp_flag =
       target_arch.GetFlags() & lldb_private::ArchSpec::eMIPS_ABI_FP_mask;
 
   const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
   const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
+  assert(r2_info && r3_info && "Basic registers should always be present.");
 
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
     value.SetValueType(Value::ValueType::Scalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
       // In MIPS register "r2" (v0) holds the integer function return values
if (*byte_size <= 16) {
           use_r3 = true;
         }
       }
 
       if (use_r2) {
         reg_ctx->ReadRegister(r2_info, r2_value);
 
         const size_t bytes_copied = r2_value.GetAsMemoryData(
-            r2_info, data_sp->GetBytes(), r2_info->byte_size, target_byte_order,
-            error);
+            *r2_info, data_sp->GetBytes(), r2_info->byte_size,
+            target_byte_order, error);
         if (bytes_copied != r2_info->byte_size)
           return return_valobj_sp;
         sucess = true;
       }
       if (use_r3) {
         reg_ctx->ReadRegister(r3_info, r3_value);
         const size_t bytes_copied = r3_value.GetAsMemoryData(
-            r3_info, data_sp->GetBytes() + r2_info->byte_size,
+            *r3_info, data_sp->GetBytes() + r2_info->byte_size,
             r3_info->byte_size, target_byte_order, error);
 
         if (bytes_copied != r3_info->byte_size)
           return return_valobj_sp;
         sucess = true;
       }
       if (sucess) {
         // The result is in our data buffer.  Create a variable object out of

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

if (byte_size && *byte_size > 0) {
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_up(
                 new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(altivec_reg, reg_value)) {
               Status error;
               if (reg_value.GetAsMemoryData(
-                      altivec_reg, heap_data_up->GetBytes(),
+                      *altivec_reg, heap_data_up->GetBytes(),
                       heap_data_up->GetByteSize(), byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_up.release()),
                                    byte_order,
                                    process_sp->GetTarget()
                                        .GetArchitecture()
                                        .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

bool GetRawData(uint64_t &raw_data) {
       RegisterValue reg_val;
       if (!m_reg_ctx->ReadRegister(reg_info, reg_val)) {
         LLDB_LOG(m_log, LOG_PREFIX "ReadRegister() failed");
         return false;
       }
 
       Status error;
       uint32_t rc = reg_val.GetAsMemoryData(
-          reg_info, &raw_data, sizeof(raw_data), m_byte_order, error);
+          *reg_info, &raw_data, sizeof(raw_data), m_byte_order, error);
       if (rc != sizeof(raw_data)) {
         LLDB_LOG(m_log, LOG_PREFIX "GetAsMemoryData() failed");
         return false;
       }
 
       return true;
     }
 
ValueObjectSP GetVectorValueObject() {
     std::unique_ptr<DataBufferHeap> vr_data(
         new DataBufferHeap(vrs * vr_size, 0));
 
     for (uint32_t i = 0; i < vrs; i++) {
       if (!m_reg_ctx->ReadRegister(vr[i], vr_val[i])) {
         LLDB_LOG(m_log, LOG_PREFIX "Failed to read vector register contents");
         return ValueObjectSP();
       }
-      if (!vr_val[i].GetAsMemoryData(vr[i], vr_data->GetBytes() + i * vr_size,
+      if (!vr_val[i].GetAsMemoryData(*vr[i], vr_data->GetBytes() + i * vr_size,
                                      vr_size, m_byte_order, error)) {
         LLDB_LOG(m_log, LOG_PREFIX "Failed to extract vector register bytes");
         return ValueObjectSP();
       }
     }
 
     // The compiler generated code seems to always put the vector elements at
     // the end of the vector register, in case they don't occupy all of it.

lldb/source/Plugins/ABI/X86/ABISysV_i386.cpp

if (byte_size && *byte_size > 0) {
           ProcessSP process_sp(thread.GetProcess());
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_up(
                 new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(vec_reg, reg_value)) {
               Status error;
-              if (reg_value.GetAsMemoryData(vec_reg, heap_data_up->GetBytes(),
+              if (reg_value.GetAsMemoryData(*vec_reg, heap_data_up->GetBytes(),
                                             heap_data_up->GetByteSize(),
                                             byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_up.release()),
                                    byte_order,
                                    process_sp->GetTarget()
                                        .GetArchitecture()
                                        .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
if (byte_size && *byte_size > 0) {
                   new DataBufferHeap(*byte_size, 0));
               const ByteOrder byte_order = process_sp->GetByteOrder();
               RegisterValue reg_value;
               RegisterValue reg_value2;
               if (reg_ctx->ReadRegister(vec_reg, reg_value) &&
                   reg_ctx->ReadRegister(vec_reg2, reg_value2)) {
 
                 Status error;
-                if (reg_value.GetAsMemoryData(vec_reg, heap_data_up->GetBytes(),
-                                              vec_reg->byte_size, byte_order,
-                                              error) &&
+                if (reg_value.GetAsMemoryData(
+                        *vec_reg, heap_data_up->GetBytes(), vec_reg->byte_size,
+                        byte_order, error) &&
                     reg_value2.GetAsMemoryData(
-                        vec_reg2, heap_data_up->GetBytes() + vec_reg->byte_size,
+                        *vec_reg2,
+                        heap_data_up->GetBytes() + vec_reg->byte_size,
                         heap_data_up->GetByteSize() - vec_reg->byte_size,
                         byte_order, error)) {
                   DataExtractor data(DataBufferSP(heap_data_up.release()),
                                      byte_order,
                                      process_sp->GetTarget()
                                          .GetArchitecture()
                                          .GetAddressByteSize());
                   return_valobj_sp = ValueObjectConstResult::Create(

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

if (byte_size && *byte_size > 0) {
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_up(
                 new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(altivec_reg, reg_value)) {
               Status error;
               if (reg_value.GetAsMemoryData(
-                      altivec_reg, heap_data_up->GetBytes(),
+                      *altivec_reg, heap_data_up->GetBytes(),
                       heap_data_up->GetByteSize(), byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_up.release()),
                                    byte_order,
                                    process_sp->GetTarget()
                                        .GetArchitecture()
                                        .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);
if (byte_size && *byte_size > 0) {
               const ByteOrder byte_order = process_sp->GetByteOrder();
               RegisterValue reg_value;
               RegisterValue reg_value2;
               if (reg_ctx->ReadRegister(altivec_reg, reg_value) &&
                   reg_ctx->ReadRegister(altivec_reg2, reg_value2)) {
 
                 Status error;
                 if (reg_value.GetAsMemoryData(
-                        altivec_reg, heap_data_up->GetBytes(),
+                        *altivec_reg, heap_data_up->GetBytes(),
                         altivec_reg->byte_size, byte_order, error) &&
                     reg_value2.GetAsMemoryData(
-                        altivec_reg2,
+                        *altivec_reg2,
                         heap_data_up->GetBytes() + altivec_reg->byte_size,
                         heap_data_up->GetByteSize() - altivec_reg->byte_size,
                         byte_order, error)) {
                   DataExtractor data(DataBufferSP(heap_data_up.release()),
                                      byte_order,
                                      process_sp->GetTarget()
                                          .GetArchitecture()
                                          .GetAddressByteSize());

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

if (byte_size && *byte_size > 0) {
           ProcessSP process_sp(thread.GetProcess());
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_up(
                 new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(xmm_reg, reg_value)) {
               Status error;
-              if (reg_value.GetAsMemoryData(
-                      xmm_reg, heap_data_up->GetBytes(),
-                      heap_data_up->GetByteSize(), byte_order, error)) {
+              if (reg_value.GetAsMemoryData(*xmm_reg, heap_data_up->GetBytes(),
+                                            heap_data_up->GetByteSize(),
+                                            byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_up.release()),
                                    byte_order,
                                    process_sp->GetTarget()
                                        .GetArchitecture()
                                        .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);
               }

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

case MemOp_STORE: {
     }
     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))
       return false;
 
-    if (data_Rt.GetAsMemoryData(&(*reg_info_Rt), buffer, reg_info_Rt->byte_size,
+    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))
       return false;
 
-    if (data_Rt2.GetAsMemoryData(&(*reg_info_Rt2), buffer,
-                                 reg_info_Rt2->byte_size, eByteOrderLittle,
-                                 error) == 0)
+    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,
                      reg_info_Rt2->byte_size))
       return false;
   } break;
 
   case MemOp_LOAD: {
case MemOp_STORE:
     else
       context.type = eContextRegisterStore;
     context.SetRegisterToRegisterPlusOffset(*reg_info_Rt, *reg_info_base,
                                             postindex ? 0 : offset);
 
     if (!ReadRegister(*reg_info_Rt, data_Rt))
       return false;
 
-    if (data_Rt.GetAsMemoryData(&(*reg_info_Rt), buffer, reg_info_Rt->byte_size,
+    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;
     break;
 
   case MemOp_LOAD:

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

if (nonvolatile_reg_p(src)) {
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
     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)
+    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;
 
     return true;
   }
 
if (base == dwarf_sp_mips && nonvolatile_reg_p(src)) {
     context.SetRegisterToRegisterPlusOffset(reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
     if (!ReadRegister(*reg_info_base, data_src))
       return false;
 
-    if (data_src.GetAsMemoryData(&reg_info_src, buffer, reg_info_src.byte_size,
+    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;
 
     return true;
   }
for (uint32_t i = 0; i < num_operands - 2; i++) {
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
     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)
+    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))
       return false;
 
     // Stack address for next register
     base_address = base_address + reg_info_src->byte_size;
   }

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

if (nonvolatile_reg_p(src)) {
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
     uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
     Status error;
 
     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)
+    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;
   }
 
   /* Set the bad_vaddr register with base address used in the instruction */
   bad_vaddr_context.type = eContextInvalid;

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

 Status
 NativeRegisterContextLinux::WriteRegisterRaw(uint32_t reg_index,
                                              const RegisterValue &reg_value) {
   uint32_t reg_to_write = reg_index;
   RegisterValue value_to_write = reg_value;
 
   // Check if this is a subregister of a full register.
   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_index);
+  assert(reg_info && "Expected valid register info for reg_index.");
   if (reg_info->invalidate_regs &&
       (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
     Status error;
 
     RegisterValue full_value;
     uint32_t full_reg = reg_info->invalidate_regs[0];
     const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
 
     // Read the full register.
     error = ReadRegister(full_reg_info, full_value);
-    if (error.Fail())
+    if (error.Fail()) {
+      // full_reg_info was nullptr, or we couldn't read the register.
       return error;
+    }
 
     lldb::ByteOrder byte_order = GetByteOrder();
     uint8_t dst[RegisterValue::kMaxRegisterByteSize];
 
     // Get the bytes for the full register.
     const uint32_t dest_size = full_value.GetAsMemoryData(
-        full_reg_info, dst, sizeof(dst), byte_order, error);
+        *full_reg_info, dst, sizeof(dst), byte_order, error);
     if (error.Success() && dest_size) {
       uint8_t src[RegisterValue::kMaxRegisterByteSize];
 
       // Get the bytes for the source data.
       const uint32_t src_size = reg_value.GetAsMemoryData(
-          reg_info, src, sizeof(src), byte_order, error);
+          *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);
         reg_to_write = full_reg;
       }

lldb/source/Target/RegisterContext.cpp

if (process_sp) {
     error.SetErrorString("invalid process");
 
   return error;
 }
 
 Status RegisterContext::WriteRegisterValueToMemory(
     const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
     const RegisterValue &reg_value) {
-  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
   Status error;
-
   ProcessSP process_sp(m_thread.GetProcess());
-  if (process_sp) {
+
+  if (!process_sp) {
+    error.SetErrorString("invalid process");
+    return error;
+  }
+
+  if (reg_info == nullptr) {
+    error.SetErrorString("Invalid register info argument.");
+    return error;
+  }
 
-    // TODO: we might need to add a parameter to this function in case the byte
-    // order of the memory data doesn't match the process. For now we are
-    // assuming they are the same.
-
-    const uint32_t bytes_copied = reg_value.GetAsMemoryData(
-        reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
+  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
+      *reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
 
-    if (error.Success()) {
-      if (bytes_copied == 0) {
-        error.SetErrorString("byte copy failed.");
-      } else {
-        const uint32_t bytes_written =
-            process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);
-        if (bytes_written != bytes_copied) {
-          if (error.Success()) {
-            // This might happen if we read _some_ bytes but not all
-            error.SetErrorStringWithFormat("only wrote %u of %u bytes",
-                                           bytes_written, bytes_copied);
-          }
-        }
-      }
-    }
-  } else
-    error.SetErrorString("invalid process");
 
   return error;
 }
 
 lldb::ByteOrder RegisterContext::GetByteOrder() {
   // Get the target process whose privileged thread was used for the register
   // read.
   lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;

lldb/source/Utility/RegisterValue.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 bool RegisterValue::GetData(DataExtractor &data) const {
   return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 }
 
-uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
+uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo &reg_info, void *dst,
                                         uint32_t dst_len,
                                         lldb::ByteOrder dst_byte_order,
                                         Status &error) const {
-  if (reg_info == nullptr) {
-    error.SetErrorString("invalid register info argument.");
-    return 0;
-  }
-
   // ReadRegister should have already been called on this object prior to
   // calling this.
   if (GetType() == eTypeInvalid) {
     // No value has been read into this object...
     error.SetErrorStringWithFormat(
-        "invalid register value type for register %s", reg_info->name);
+        "invalid register value type for register %s", reg_info.name);
     return 0;
   }
 
   if (dst_len > kMaxRegisterByteSize) {
     error.SetErrorString("destination is too big");
     return 0;
   }
 
-  const uint32_t src_len = reg_info->byte_size;
+  const uint32_t src_len = reg_info.byte_size;
 
   // Extract the register data into a data extractor
   DataExtractor reg_data;
   if (!GetData(reg_data)) {
     error.SetErrorString("invalid register value to copy into");
     return 0;
   }
 
   // Prepare a memory buffer that contains some or all of the register value
   const uint32_t bytes_copied =
       reg_data.CopyByteOrderedData(0,               // src offset
                                    src_len,         // src length
                                    dst,             // dst buffer
                                    dst_len,         // dst length
                                    dst_byte_order); // dst byte order
   if (bytes_copied == 0)
     error.SetErrorStringWithFormat(
-        "failed to copy data for register write of %s", reg_info->name);
+        "failed to copy data for register write of %s", reg_info.name);
 
   return bytes_copied;
 }
 
 uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
                                           const void *src, uint32_t src_len,
                                           lldb::ByteOrder src_byte_order,
                                           Status &error) {