[lldb] Use SmallVector for handling register data

[DavidSpickett]

Summary

Previously lldb was using arrays of size kMaxRegisterByteSize to handle
registers. This was set to 256 because the largest possible register
we support is Arm's scalable vectors (SVE) which can be up to 256 bytes long.

This means for most operations aside from SVE, we're wasting 192 bytes
of it. Which is ok given that we don't have to pay the cost of a heap
alocation and 256 bytes isn't all that much overall.

With the introduction of the Arm Scalable Matrix extension there is a new
array storage register, ZA. This register is essentially a square made up of
SVE vectors. Therefore ZA could be up to 64kb in size.

https://developer.arm.com/documentation/ddi0616/latest/

"The Effective Streaming SVE vector length, SVL, is a power of two in the range 128 to 2048 bits inclusive."

"The ZA storage is architectural register state consisting of a two-dimensional ZA array of [SVLB × SVLB] bytes."

99% of operations will never touch ZA and making every stack frame 64kb+ just
for that slim chance is a bad idea.

Instead I'm switching register handling to use SmallVector with a stack allocation
size of kTypicalRegisterByteSize. kMaxRegisterByteSize will be used in places
where we can't predict the size of register we're reading (in the GDB remote client).

The result is that the 99% of small register operations can use the stack
as before and the actual ZA operations will move to the heap as needed.

I tested this by first working out -wframe-larger-than values for all the
libraries using the arrays previously. With this change I was able to increase
kMaxRegisterByteSize to 256*256 without hitting those limits. With the
exception of the GDB server which needs to use a max size buffer.

[DavidSpickett]

This assumes that the usual use case is:

• Make a small vector.
• Resize it to what you need.
• Use the content like an array.

Every case I found matched that but still, it's not the safest API ever. So I've tested this on arm64 of course, and did try to run the test suite with asan but issues with leaks in Python prevented that. No amount of filtering seemed to help.

I see Green Dragon runs an lldb sanitizers bot, so my plan would be to rely on that to catch any tricky issues prior to any SME changes going in.

lldb/include/lldb/Utility/RegisterValue.h

36

When the ZA register is added, this will change to 256*256. For now nothing should change apart from the slight overhead of SmallVector.

[JDevlieghere]

In D153626#4444096, @DavidSpickett wrote:

This assumes that the usual use case is:

• Make a small vector.
• Resize it to what you need.
• Use the content like an array.

Every case I found matched that but still, it's not the safest API ever.

Yeah, I don't see how we can make this any safer without introducing something like the DataExtractor but for writing rather than reading, which would be overkill, and if we care about the cost of heap allocations, probably too slow as well. The current approach doesn't seem any less safe than the buffer we had before so I think it's fine.

In D153626#4444096, @DavidSpickett wrote:

I see Green Dragon runs an lldb sanitizers bot, so my plan would be to rely on that to catch any tricky issues prior to any SME changes going in.

The sanitized bot on GreenDragon runs on Intel and I assume the "risky' changes only apply to arm64 as that's the only architecture that needs to scale beyond the default 256? Anyway I haven't seen the leaks issue you've mentioned locally so I'm happy to run a sanitized build on arm64.

[DavidSpickett]

The sanitized bot on GreenDragon runs on Intel and I assume the "risky' changes only apply to arm64 as that's the only architecture that needs to scale beyond the default 256? Anyway I haven't seen the leaks issue you've mentioned locally so I'm happy to run a sanitized build on arm64.

The risk for existing targets is that .size() won't reflect the size we're about to write to it. With it defaulting to 256 bytes of stack space and us using it like an array, we'd probably skip a lot of the SmallVector asserts around that.

Potentially I could "proxy" .resize and assert that it had been called at some point but it's still possible to forget to resize it again if it was needed. It would make more sense to look at the methods we pass the SmallVector's storage to instead. If they could take the container directly, then they could do some checks.

I will look into that, and I will also try the sanitized build again because now I wonder if lit's env cleaning was removing the options I needed.

[DavidSpickett]

Make a resize in EmulateInstructionARM64::EmulateLDPSTP uncondintional.

Though in this case the register for an ldp/stp could only be an x register
which is 8 bytes, so there would have been enough allocated already.

[DavidSpickett]

Drop {} in one place now that the resize is not conditional. The logic
there also seems faulty, but in other ways I will stay out of for now.

I did attempt another sanitizers build and realised I should have been
setting leak checker options. That got me to missing symbols, and
no amount of preloading seemed to help there. Not sure what went wrong.

I looked at asserting or adding some checker methods. Given that you're
going to resize to X then pass X as the size to the subsequent call,
there's not much value in it. It would prevent some typos maybe.

On the same theme I looked at adding overloads that took smallvector
directly, but with only 3/4 calls to each one it just didn't seem worth it.

The existing uses are compact enough to check manually and/or in a
sanitized build.

lldb/include/lldb/Utility/RegisterValue.h

 #define LLDB_UTILITY_REGISTERVALUE_H
 
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <cstring>
 #include <utility>
 
 namespace lldb_private {
 class DataExtractor;
 class Stream;
 struct RegisterInfo;
 
 class RegisterValue {
 public:
-  // big enough to support up to 256 byte AArch64 SVE
-  enum { kMaxRegisterByteSize = 256u };
+  enum {
+    // What we can reasonably put on the stack, big enough to support up to 256
+    // byte AArch64 SVE.
+    kTypicalRegisterByteSize = 256u,
+    // Anything else we'll heap allocate storage for it.
+    kMaxRegisterByteSize = kTypicalRegisterByteSize,
+  };
+
+  typedef llvm::SmallVector<uint8_t, kTypicalRegisterByteSize> BytesContainer;
 
   enum Type {
     eTypeInvalid,
     eTypeUInt8,
     eTypeUInt16,
     eTypeUInt32,
     eTypeUInt64,
     eTypeUInt128,
public:
   lldb::ByteOrder GetByteOrder() const {
     if (m_type == eTypeBytes)
       return buffer.byte_order;
     return endian::InlHostByteOrder();
   }
 
   uint32_t GetByteSize() const;
 
-  static uint32_t GetMaxByteSize() { return kMaxRegisterByteSize; }
-
   void Clear();
 
 protected:
   RegisterValue::Type m_type = eTypeInvalid;
   Scalar m_scalar;
 
-  struct {
-    mutable uint8_t
-        bytes[kMaxRegisterByteSize]; // This must be big enough to hold any
-                                     // register for any supported target.
-    uint16_t length = 0;
+  struct RegisterValueBuffer {
+    // Start at max stack storage size. Move to the heap for anything larger.
+    RegisterValueBuffer() : bytes(kTypicalRegisterByteSize) {}
+
+    mutable BytesContainer bytes;
     lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
   } buffer;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_REGISTERVALUE_H

lldb/source/Host/common/NativeRegisterContext.cpp

Status NativeRegisterContext::ReadRegisterValueFromMemory(
   //
   //   Status!  (The register should always be big enough to hold the data)
   //
   // Case 3: src_len < dst_len
   //
   //   |AABB| Address contents
   //   |AABB0000| Register contents [on little-endian hardware]
   //   |0000AABB| Register contents [on big-endian hardware]
-  if (src_len > RegisterValue::kMaxRegisterByteSize) {
-    error.SetErrorString("register too small to receive memory data");
-    return error;
-  }
-
   const size_t dst_len = reg_info->byte_size;
 
   if (src_len > dst_len) {
     error.SetErrorStringWithFormat(
         "%" PRIu64 " bytes is too big to store in register %s (%" PRIu64
         " bytes)",
         static_cast<uint64_t>(src_len), reg_info->name,
         static_cast<uint64_t>(dst_len));
     return error;
   }
 
   NativeProcessProtocol &process = m_thread.GetProcess();
-  uint8_t src[RegisterValue::kMaxRegisterByteSize];
+  RegisterValue::BytesContainer src(src_len);
 
   // Read the memory
   size_t bytes_read;
-  error = process.ReadMemory(src_addr, src, src_len, bytes_read);
+  error = process.ReadMemory(src_addr, src.data(), src_len, bytes_read);
   if (error.Fail())
     return error;
 
   // Make sure the memory read succeeded...
   if (bytes_read != src_len) {
     // This might happen if we read _some_ bytes but not all
     error.SetErrorStringWithFormat("read %" PRIu64 " of %" PRIu64 " bytes",
                                    static_cast<uint64_t>(bytes_read),
                                    static_cast<uint64_t>(src_len));
     return error;
   }
 
   // We now have a memory buffer that contains the part or all of the register
   // value. Set the register value using this memory data.
   // 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.
-  reg_value.SetFromMemoryData(*reg_info, src, src_len, process.GetByteOrder(),
-                              error);
+  reg_value.SetFromMemoryData(*reg_info, src.data(), 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) {
   Status error;
   if (reg_info == nullptr) {
     error.SetErrorString("Invalid register info argument.");
     return error;
   }
 
-  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
+  RegisterValue::BytesContainer dst(dst_len);
   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.data(), 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);
+      error = process.WriteMemory(dst_addr, dst.data(), bytes_copied,
+                                  bytes_written);
       if (error.Fail())
         return error;
 
       if (bytes_written != bytes_copied) {
         // This might happen if we read _some_ bytes but not all
         error.SetErrorStringWithFormat("only wrote %" PRIu64 " of %" PRIu64
                                        " bytes",
                                        static_cast<uint64_t>(bytes_written),

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

if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
           // Don't handle complex yet.
           error.SetErrorString(
               "returning complex float values are not supported");
         } else {
           const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
           if (v0_info) {
             if (byte_size <= 16) {
-              if (byte_size <= RegisterValue::GetMaxByteSize()) {
-                RegisterValue reg_value;
-                error = reg_value.SetValueFromData(*v0_info, data, 0, true);
-                if (error.Success()) {
-                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                    error.SetErrorString("failed to write register v0");
-                }
-              } else {
-                error.SetErrorStringWithFormat(
-                    "returning float values with a byte size of %" PRIu64
-                    " are not supported",
-                    byte_size);
-              }
+              if (error.Success())
             } else {
               error.SetErrorString("returning float values longer than 128 "
                                    "bits are not supported");
             }
-          } else {
+          } else
             error.SetErrorString("v0 register is not available on this target");
-          }
-        }
-      }
     } else if (type_flags & eTypeIsVector) {
       if (byte_size > 0) {
         const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
         if (v0_info) {
           if (byte_size <= v0_info->byte_size) {
             RegisterValue reg_value;
             error = reg_value.SetValueFromData(*v0_info, data, 0, true);

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

if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
           // Don't handle complex yet.
           error.SetErrorString(
               "returning complex float values are not supported");
         } else {
           const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
           if (v0_info) {
             if (byte_size <= 16) {
-              if (byte_size <= RegisterValue::GetMaxByteSize()) {
-                RegisterValue reg_value;
-                error = reg_value.SetValueFromData(*v0_info, data, 0, true);
-                if (error.Success()) {
-                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                    error.SetErrorString("failed to write register v0");
-                }
-              } else {
-                error.SetErrorStringWithFormat(
-                    "returning float values with a byte size of %" PRIu64
-                    " are not supported",
-                    byte_size);
-              }
+              if (error.Success())
             } else {
               error.SetErrorString("returning float values longer than 128 "
                                    "bits are not supported");
             }
-          } else {
+          } else
             error.SetErrorString("v0 register is not available on this target");
-          }
-        }
-      }
     } else if (type_flags & eTypeIsVector) {
       if (byte_size > 0) {
         const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
         if (v0_info) {
           if (byte_size <= v0_info->byte_size) {
             RegisterValue reg_value;
             error = reg_value.SetValueFromData(*v0_info, data, 0, true);

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

 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Support/CheckedArithmetic.h"
 
 #include "Plugins/Process/Utility/ARMDefines.h"
 #include "Plugins/Process/Utility/ARMUtils.h"
 #include "Plugins/Process/Utility/lldb-arm64-register-enums.h"
 
+#include <algorithm>
 #include <cstdlib>
 #include <optional>
 
 #define GPR_OFFSET(idx) ((idx)*8)
 #define GPR_OFFSET_NAME(reg) 0
 #define FPU_OFFSET(idx) ((idx)*16)
 #define FPU_OFFSET_NAME(reg) 0
 #define EXC_OFFSET_NAME(reg) 0
bool EmulateInstructionARM64::EmulateLDPSTP(const uint32_t opcode) {
 
   wb_address = address + idx;
   if (a_mode != AddrMode_POST)
     address = wb_address;
 
   Context context_t;
   Context context_t2;
 
-  uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
+  RegisterValue::BytesContainer buffer;
   Status error;
 
   switch (memop) {
   case MemOp_STORE: {
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is
                                                          // based off of the sp
                                                          // or fp register
     {
       context_t.type = eContextPushRegisterOnStack;
       context_t2.type = eContextPushRegisterOnStack;
     } 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);
 
     std::optional<RegisterValue> data_Rt = ReadRegister(*reg_info_Rt);
     if (!data_Rt)
       return false;
 
-    if (data_Rt->GetAsMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
-                                 eByteOrderLittle, error) == 0)
+    buffer.resize(reg_info_Rt->byte_size);
+    if (data_Rt->GetAsMemoryData(*reg_info_Rt, buffer.data(),
+                                 reg_info_Rt->byte_size, eByteOrderLittle,
+                                 error) == 0)
       return false;
 
-    if (!WriteMemory(context_t, address + 0, buffer, reg_info_Rt->byte_size))
+    if (!WriteMemory(context_t, address + 0, buffer.data(),
+                     reg_info_Rt->byte_size))
       return false;
 
     std::optional<RegisterValue> data_Rt2 = ReadRegister(*reg_info_Rt2);
     if (!data_Rt2)
       return false;
 
-    if (data_Rt2->GetAsMemoryData(*reg_info_Rt2, buffer,
+    buffer.resize(reg_info_Rt2->byte_size);
+    if (data_Rt2->GetAsMemoryData(*reg_info_Rt2, buffer.data(),
                                   reg_info_Rt2->byte_size, eByteOrderLittle,
                                   error) == 0)
       return false;
 
-    if (!WriteMemory(context_t2, address + size, buffer,
+    if (!WriteMemory(context_t2, address + size, buffer.data(),
                      reg_info_Rt2->byte_size))
       return false;
   } break;
 
   case MemOp_LOAD: {
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this load is
                                                          // based off of the sp
                                                          // or fp register
     {
       context_t.type = eContextPopRegisterOffStack;
       context_t2.type = eContextPopRegisterOffStack;
     } else {
       context_t.type = eContextRegisterLoad;
       context_t2.type = eContextRegisterLoad;
     }
     context_t.SetAddress(address);
     context_t2.SetAddress(address + size);
 
+    buffer.resize(reg_info_Rt->byte_size);
     if (rt_unknown)
-      memset(buffer, 'U', reg_info_Rt->byte_size);
+      std::fill(buffer.begin(), buffer.end(), 'U');
     else {
-      if (!ReadMemory(context_t, address, buffer, reg_info_Rt->byte_size))
+      if (!ReadMemory(context_t, address, buffer.data(),
+                      reg_info_Rt->byte_size))
         return false;
     }
 
     RegisterValue data_Rt;
-    if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
-                                  eByteOrderLittle, error) == 0)
+    if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer.data(),
+                                  reg_info_Rt->byte_size, eByteOrderLittle,
+                                  error) == 0)
       return false;
 
     if (!vector && is_signed && !data_Rt.SignExtend(datasize))
       return false;
 
     if (!WriteRegister(context_t, *reg_info_Rt, data_Rt))
       return false;
 
-    if (!rt_unknown) {
-      if (!ReadMemory(context_t2, address + size, buffer,
+    buffer.resize(reg_info_Rt2->byte_size);
+    if (!rt_unknown)
+      if (!ReadMemory(context_t2, address + size, buffer.data(),
                       reg_info_Rt2->byte_size))
         return false;
-    }
 
     RegisterValue data_Rt2;
-    if (data_Rt2.SetFromMemoryData(*reg_info_Rt2, buffer,
+    if (data_Rt2.SetFromMemoryData(*reg_info_Rt2, buffer.data(),
                                    reg_info_Rt2->byte_size, eByteOrderLittle,
                                    error) == 0)
       return false;
 
     if (!vector && is_signed && !data_Rt2.SignExtend(datasize))
       return false;
 
     if (!WriteRegister(context_t2, *reg_info_Rt2, data_Rt2))
if (Bit32(opc, 1) == 0) {
     memop = MemOp_LOAD;
     if (size == 2 && Bit32(opc, 0) == 1)
       return false;
   }
 
   Status error;
   bool success = false;
   uint64_t address;
-  uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
+  RegisterValue::BytesContainer buffer;
 
   if (n == 31)
     address =
         ReadRegisterUnsigned(eRegisterKindLLDB, gpr_sp_arm64, 0, &success);
   else
     address =
         ReadRegisterUnsigned(eRegisterKindLLDB, gpr_x0_arm64 + n, 0, &success);
 
else
       context.type = eContextRegisterStore;
     context.SetRegisterToRegisterPlusOffset(*reg_info_Rt, *reg_info_base,
                                             postindex ? 0 : offset);
 
     std::optional<RegisterValue> data_Rt = ReadRegister(*reg_info_Rt);
     if (!data_Rt)
       return false;
 
-    if (data_Rt->GetAsMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
-                                 eByteOrderLittle, error) == 0)
+    buffer.resize(reg_info_Rt->byte_size);
+    if (data_Rt->GetAsMemoryData(*reg_info_Rt, buffer.data(),
+                                 reg_info_Rt->byte_size, eByteOrderLittle,
+                                 error) == 0)
       return false;
 
-    if (!WriteMemory(context, address, buffer, reg_info_Rt->byte_size))
+    if (!WriteMemory(context, address, buffer.data(), reg_info_Rt->byte_size))
       return false;
   } break;
 
   case MemOp_LOAD: {
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is
                                                          // based off of the sp
                                                          // or fp register
       context.type = eContextPopRegisterOffStack;
     else
       context.type = eContextRegisterLoad;
     context.SetAddress(address);
 
-    if (!ReadMemory(context, address, buffer, reg_info_Rt->byte_size))
+    buffer.resize(reg_info_Rt->byte_size);
+    if (!ReadMemory(context, address, buffer.data(), reg_info_Rt->byte_size))
       return false;
 
     RegisterValue data_Rt;
-    if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
-                                  eByteOrderLittle, error) == 0)
+    if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer.data(),
+                                  reg_info_Rt->byte_size, eByteOrderLittle,
+                                  error) == 0)
       return false;
 
     if (!WriteRegister(context, *reg_info_Rt, data_Rt))
       return false;
   } break;
   default:
     return false;
   }

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

std::optional<RegisterInfo> reg_info_src =
         GetRegisterInfo(eRegisterKindDWARF, dwarf_zero_mips + src);
     if (!reg_info_src)
       return false;
 
     Context context;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
-    uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
+    RegisterValue::BytesContainer buffer(reg_info_src->byte_size);
     Status error;
 
     std::optional<RegisterValue> data_src = ReadRegister(*reg_info_base);
     if (!data_src)
       return false;
 
-    if (data_src->GetAsMemoryData(*reg_info_src, buffer,
+    if (data_src->GetAsMemoryData(*reg_info_src, buffer.data(),
                                   reg_info_src->byte_size, eByteOrderLittle,
                                   error) == 0)
       return false;
 
-    if (!WriteMemory(context, address, buffer, reg_info_src->byte_size))
+    if (!WriteMemory(context, address, buffer.data(), reg_info_src->byte_size))
       return false;
 
     return true;
   }
 
   return false;
 }
 
bool EmulateInstructionMIPS::Emulate_SWSP(llvm::MCInst &insn) {
 
   // We look for sp based non-volatile register stores.
   if (base == dwarf_sp_mips && nonvolatile_reg_p(src)) {
     RegisterInfo reg_info_src = {};
     Context context;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(reg_info_src, *reg_info_base, 0);
 
-    uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
+    RegisterValue::BytesContainer buffer(reg_info_src.byte_size);
     Status error;
 
     std::optional<RegisterValue> data_src = ReadRegister(*reg_info_base);
     if (!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.data(),
+                                  reg_info_src.byte_size, eByteOrderLittle,
+                                  error) == 0)
       return false;
 
-    if (!WriteMemory(context, address, buffer, reg_info_src.byte_size))
+    if (!WriteMemory(context, address, buffer.data(), reg_info_src.byte_size))
       return false;
 
     return true;
   }
 
   return false;
 }
 
std::optional<RegisterInfo> reg_info_src =
         GetRegisterInfo(eRegisterKindDWARF, dwarf_zero_mips + src);
     if (!reg_info_src)
       return false;
 
     Context context;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
-    uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
+    RegisterValue::BytesContainer buffer(reg_info_src->byte_size);
     Status error;
 
     std::optional<RegisterValue> data_src = ReadRegister(*reg_info_base);
     if (!data_src)
       return false;
 
-    if (data_src->GetAsMemoryData(*reg_info_src, buffer,
+    if (data_src->GetAsMemoryData(*reg_info_src, buffer.data(),
                                   reg_info_src->byte_size, eByteOrderLittle,
                                   error) == 0)
       return false;
 
-    if (!WriteMemory(context, base_address, buffer, reg_info_src->byte_size))
+    if (!WriteMemory(context, base_address, buffer.data(),
+                     reg_info_src->byte_size))
       return false;
 
     // Stack address for next register
     base_address = base_address + reg_info_src->byte_size;
   }
   return true;
 }
 

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

bool EmulateInstructionMIPS64::Emulate_SD(llvm::MCInst &insn) {
   address = address + imm;
 
   /* We look for sp based non-volatile register stores */
   if (nonvolatile_reg_p(src)) {
     Context context;
     context.type = eContextPushRegisterOnStack;
     context.SetRegisterToRegisterPlusOffset(*reg_info_src, *reg_info_base, 0);
 
-    uint8_t buffer[RegisterValue::kMaxRegisterByteSize];
-    Status error;
-
     std::optional<RegisterValue> data_src = ReadRegister(*reg_info_base);
     if (!data_src)
       return false;
 
-    if (data_src->GetAsMemoryData(*reg_info_src, buffer,
+    Status error;
+    RegisterValue::BytesContainer buffer(reg_info_src->byte_size);
+    if (data_src->GetAsMemoryData(*reg_info_src, buffer.data(),
                                   reg_info_src->byte_size, eByteOrderLittle,
                                   error) == 0)
       return false;
 
-    if (!WriteMemory(context, address, buffer, reg_info_src->byte_size))
+    if (!WriteMemory(context, address, buffer.data(), reg_info_src->byte_size))
       return false;
   }
 
   /* Set the bad_vaddr register with base address used in the instruction */
   bad_vaddr_context.type = eContextInvalid;
   WriteRegisterUnsigned(bad_vaddr_context, eRegisterKindDWARF, dwarf_bad_mips64,
                         address);
 

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

if (reg_info->invalidate_regs &&
     // Read the full register.
     error = ReadRegister(full_reg_info, full_value);
     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];
+    RegisterValue::BytesContainer dst(full_reg_info->byte_size);
 
     // 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.data(), dst.size(), byte_order, error);
     if (error.Success() && dest_size) {
-      uint8_t src[RegisterValue::kMaxRegisterByteSize];
+      RegisterValue::BytesContainer src(reg_info->byte_size);
 
       // 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.data(), src.size(), 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);
+        memcpy(dst.data() + (reg_info->byte_offset & 0x1), src.data(),
+               src_size);
         // Set this full register as the value to write.
-        value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
+        value_to_write.SetBytes(dst.data(), full_value.GetByteSize(),
+                                byte_order);
         value_to_write.SetType(*full_reg_info);
         reg_to_write = full_reg;
       }
     }
   }
 
   const RegisterInfo *const register_to_write_info_p =
       GetRegisterInfoAtIndex(reg_to_write);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

 
 #include <mutex>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationServerCommon.h"
 
 class StringExtractorGDBRemote;
 
 namespace lldb_private {
 
protected:
   bool m_list_threads_in_stop_reply = false;
   bool m_non_stop = false;
   bool m_disabling_non_stop = false;
   std::deque<std::string> m_stdio_notification_queue;
   std::deque<std::string> m_stop_notification_queue;
 
   NativeProcessProtocol::Extension m_extensions_supported = {};
 
+  // Typically we would use a SmallVector for this data but in this context we
+  // don't know how much data we're recieving so we would have to heap allocate
+  // a lot, or have a very large stack frame. So it's a member instead.
+  uint8_t m_reg_bytes[RegisterValue::kMaxRegisterByteSize];
+
   PacketResult SendONotification(const char *buffer, uint32_t len);
 
   PacketResult SendWResponse(NativeProcessProtocol *process);
 
   StreamString PrepareStopReplyPacketForThread(NativeThreadProtocol &thread);
 
   PacketResult SendStopReplyPacketForThread(NativeProcessProtocol &process,
                                             lldb::tid_t tid,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/GDBRemote.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
-#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/Utility/UriParser.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/TargetParser/Triple.h"
 
GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
   }
 
   // Note debugserver would send an E30 here.
   if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '='))
     return SendIllFormedResponse(
         packet, "P packet missing '=' char after register number");
 
   // Parse out the value.
-  uint8_t reg_bytes[RegisterValue::kMaxRegisterByteSize];
-  size_t reg_size = packet.GetHexBytesAvail(reg_bytes);
+  size_t reg_size = packet.GetHexBytesAvail(m_reg_bytes);
 
   // Get the thread to use.
   NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
   if (!thread) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s failed, no thread "
               "available (thread index 0)",
               __FUNCTION__);
GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
   }
 
   if (reg_size != reg_info->byte_size)
     return SendIllFormedResponse(packet, "P packet register size is incorrect");
 
   // Build the reginfos response.
   StreamGDBRemote response;
 
-  RegisterValue reg_value(ArrayRef(reg_bytes, reg_size),
+  RegisterValue reg_value(ArrayRef(m_reg_bytes, reg_size),
                           m_current_process->GetArchitecture().GetByteOrder());
   Status error = reg_context.WriteRegister(reg_info, reg_value);
   if (error.Fail()) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s failed, write of "
               "requested register %" PRIu32 " (%s) failed: %s",
               __FUNCTION__, reg_index, reg_info->name, error.AsCString());
     return SendErrorResponse(0x32);

lldb/source/Target/RegisterContext.cpp

Status RegisterContext::ReadRegisterValueFromMemory(
   //
   //   Status!  (The register should always be big enough to hold the data)
   //
   // Case 3: src_len < dst_len
   //
   //   |AABB| Address contents
   //   |AABB0000| Register contents [on little-endian hardware]
   //   |0000AABB| Register contents [on big-endian hardware]
-  if (src_len > RegisterValue::kMaxRegisterByteSize) {
-    error.SetErrorString("register too small to receive memory data");
-    return error;
-  }
-
   const uint32_t dst_len = reg_info->byte_size;
 
   if (src_len > dst_len) {
     error.SetErrorStringWithFormat(
         "%u bytes is too big to store in register %s (%u bytes)", src_len,
         reg_info->name, dst_len);
     return error;
   }
 
   ProcessSP process_sp(m_thread.GetProcess());
   if (process_sp) {
-    uint8_t src[RegisterValue::kMaxRegisterByteSize];
+    RegisterValue::BytesContainer src(src_len);
 
     // Read the memory
     const uint32_t bytes_read =
-        process_sp->ReadMemory(src_addr, src, src_len, error);
+        process_sp->ReadMemory(src_addr, src.data(), src_len, error);
 
     // Make sure the memory read succeeded...
     if (bytes_read != src_len) {
       if (error.Success()) {
         // This might happen if we read _some_ bytes but not all
         error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read,
                                        src_len);
       }
       return error;
     }
 
     // We now have a memory buffer that contains the part or all of the
     // register value. Set the register value using this memory data.
     // 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.
-    reg_value.SetFromMemoryData(*reg_info, src, src_len,
+    reg_value.SetFromMemoryData(*reg_info, src.data(), src_len,
                                 process_sp->GetByteOrder(), error);
   } else
     error.SetErrorString("invalid process");
 
   return error;
 }
 
 Status RegisterContext::WriteRegisterValueToMemory(
Status RegisterContext::WriteRegisterValueToMemory(
   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.
-  uint8_t dst[RegisterValue::kMaxRegisterByteSize];
+  RegisterValue::BytesContainer dst(dst_len);
   const uint32_t bytes_copied = reg_value.GetAsMemoryData(
-      *reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
+      *reg_info, dst.data(), 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);
+          process_sp->WriteMemory(dst_addr, dst.data(), 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);
         }
       }
     }

lldb/source/Utility/RegisterValue.cpp

uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo &reg_info, void *dst,
   // 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);
     return 0;
   }
 
-  if (dst_len > kMaxRegisterByteSize) {
-    error.SetErrorString("destination is too big");
-    return 0;
-  }
-
   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;
   }
uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo &reg_info,
   //
   //   Status!  (The register should always be big enough to hold the data)
   //
   // Case 3: src_len < dst_len
   //
   //   |AABB| Address contents
   //   |AABB0000| Register contents [on little-endian hardware]
   //   |0000AABB| Register contents [on big-endian hardware]
-  if (src_len > kMaxRegisterByteSize) {
-    error.SetErrorStringWithFormat(
-        "register buffer is too small to receive %u bytes of data.", src_len);
-    return 0;
-  }
-
   const uint32_t dst_len = reg_info.byte_size;
 
   if (src_len > dst_len) {
     error.SetErrorStringWithFormat(
         "%u bytes is too big to store in register %s (%u bytes)", src_len,
         reg_info.name, dst_len);
     return 0;
   }
uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo &reg_info,
   return src_len;
 }
 
 bool RegisterValue::GetScalarValue(Scalar &scalar) const {
   switch (m_type) {
   case eTypeInvalid:
     break;
   case eTypeBytes: {
-    DataExtractor data(buffer.bytes, buffer.length, buffer.byte_order, 1);
-    if (scalar.SetValueFromData(data, lldb::eEncodingUint,
-    buffer.length).Success())
+    DataExtractor data(buffer.bytes.data(), buffer.bytes.size(),
+                       buffer.byte_order, 1);
+    if (scalar.SetValueFromData(data, lldb::eEncodingUint, buffer.bytes.size())
+            .Success())
       return true;
   } break;
   case eTypeUInt8:
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeUInt128:
   case eTypeFloat:
if (!partial_data_ok && (src_len < reg_info.byte_size)) {
     return error;
   }
 
   // Cap the data length if there is more than enough bytes for this register
   // value
   if (src_len > reg_info.byte_size)
     src_len = reg_info.byte_size;
 
-  // Zero out the value in case we get partial data...
-  memset(buffer.bytes, 0, sizeof(buffer.bytes));
-
   type128 int128;
 
   m_type = eTypeInvalid;
   switch (reg_info.encoding) {
   case eEncodingInvalid:
     break;
   case eEncodingUint:
   case eEncodingSint:
if (reg_info.byte_size == sizeof(float))
       SetFloat(src.GetFloat(&src_offset));
     else if (reg_info.byte_size == sizeof(double))
       SetDouble(src.GetDouble(&src_offset));
     else if (reg_info.byte_size == sizeof(long double))
       SetLongDouble(src.GetLongDouble(&src_offset));
     break;
   case eEncodingVector: {
     m_type = eTypeBytes;
-    buffer.length = reg_info.byte_size;
+    assert(reg_info.byte_size <= kMaxRegisterByteSize);
+    buffer.bytes.resize(reg_info.byte_size);
     buffer.byte_order = src.GetByteOrder();
-    assert(buffer.length <= kMaxRegisterByteSize);
-    if (buffer.length > kMaxRegisterByteSize)
-      buffer.length = kMaxRegisterByteSize;
     if (src.CopyByteOrderedData(
-            src_offset,    // offset within "src" to start extracting data
-            src_len,       // src length
-            buffer.bytes,  // dst buffer
-            buffer.length, // dst length
+            src_offset,          // offset within "src" to start extracting data
+            src_len,             // src length
+            buffer.bytes.data(), // dst buffer
+            buffer.bytes.size(), // dst length
             buffer.byte_order) == 0) // dst byte order
     {
       error.SetErrorStringWithFormat(
           "failed to copy data for register write of %s", reg_info.name);
       return error;
     }
   }
   }
bool RegisterValue::CopyValue(const RegisterValue &rhs) {
   case eTypeUInt64:
   case eTypeUInt128:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     m_scalar = rhs.m_scalar;
     break;
   case eTypeBytes:
-    assert(rhs.buffer.length <= kMaxRegisterByteSize);
-    ::memcpy(buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
-    buffer.length = rhs.buffer.length;
+    buffer.bytes = rhs.buffer.bytes;
     buffer.byte_order = rhs.buffer.byte_order;
     break;
   }
   return true;
 }
 
 uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
                                     bool *success_ptr) const {
   if (success_ptr)
     *success_ptr = true;
 
   switch (m_type) {
   default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
     return m_scalar.UShort(fail_value);
   case eTypeBytes: {
-    switch (buffer.length) {
+    switch (buffer.bytes.size()) {
     default:
       break;
     case 1:
     case 2:
-      return *reinterpret_cast<const uint16_t *>(buffer.bytes);
+      return *reinterpret_cast<const uint16_t *>(buffer.bytes.data());
     }
   } break;
   }
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
 uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
                                     bool *success_ptr) const {
   if (success_ptr)
     *success_ptr = true;
   switch (m_type) {
   default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     return m_scalar.UInt(fail_value);
   case eTypeBytes: {
-    switch (buffer.length) {
+    switch (buffer.bytes.size()) {
     default:
       break;
     case 1:
     case 2:
     case 4:
-      return *reinterpret_cast<const uint32_t *>(buffer.bytes);
+      return *reinterpret_cast<const uint32_t *>(buffer.bytes.data());
     }
   } break;
   }
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
 uint64_t RegisterValue::GetAsUInt64(uint64_t fail_value,
                                     bool *success_ptr) const {
   if (success_ptr)
     *success_ptr = true;
   switch (m_type) {
   default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     return m_scalar.ULongLong(fail_value);
   case eTypeBytes: {
-    switch (buffer.length) {
+    switch (buffer.bytes.size()) {
     default:
       break;
     case 1:
-      return *(const uint8_t *)buffer.bytes;
+      return *(const uint8_t *)buffer.bytes.data();
     case 2:
-      return *reinterpret_cast<const uint16_t *>(buffer.bytes);
+      return *reinterpret_cast<const uint16_t *>(buffer.bytes.data());
     case 4:
-      return *reinterpret_cast<const uint32_t *>(buffer.bytes);
+      return *reinterpret_cast<const uint32_t *>(buffer.bytes.data());
     case 8:
-      return *reinterpret_cast<const uint64_t *>(buffer.bytes);
+      return *reinterpret_cast<const uint64_t *>(buffer.bytes.data());
     }
   } break;
   }
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
llvm::APInt RegisterValue::GetAsUInt128(const llvm::APInt &fail_value,
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeUInt128:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     return m_scalar.UInt128(fail_value);
   case eTypeBytes: {
-    switch (buffer.length) {
+    switch (buffer.bytes.size()) {
     default:
       break;
     case 1:
     case 2:
     case 4:
     case 8:
     case 16:
-      return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                         (reinterpret_cast<const type128 *>(buffer.bytes))->x);
+      return llvm::APInt(
+          BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+          (reinterpret_cast<const type128 *>(buffer.bytes.data()))->x);
     }
   } break;
   }
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
const void *RegisterValue::GetBytes() const {
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeUInt128:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     m_scalar.GetBytes(buffer.bytes);
-    return buffer.bytes;
+    return buffer.bytes.data();
   case eTypeBytes:
-    return buffer.bytes;
+    return buffer.bytes.data();
   }
   return nullptr;
 }
 
 uint32_t RegisterValue::GetByteSize() const {
   switch (m_type) {
   case eTypeInvalid:
     break;
   case eTypeUInt8:
     return 1;
   case eTypeUInt16:
     return 2;
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeUInt128:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
     return m_scalar.GetByteSize();
   case eTypeBytes:
-    return buffer.length;
+    return buffer.bytes.size();
   }
   return 0;
 }
 
 bool RegisterValue::SetUInt(uint64_t uint, uint32_t byte_size) {
   if (byte_size == 0) {
     SetUInt64(uint);
   } else if (byte_size == 1) {
     SetUInt8(uint);
   } else if (byte_size <= 2) {
     SetUInt16(uint);
   } else if (byte_size <= 4) {
     SetUInt32(uint);
   } else if (byte_size <= 8) {
     SetUInt64(uint);
   } else if (byte_size <= 16) {
     SetUInt128(llvm::APInt(128, uint));
   } else
     return false;
   return true;
 }
 
 void RegisterValue::SetBytes(const void *bytes, size_t length,
                              lldb::ByteOrder byte_order) {
-  // If this assertion fires off we need to increase the size of buffer.bytes,
-  // or make it something that is allocated on the heap. Since the data buffer
-  // is in a union, we can't make it a collection class like SmallVector...
   if (bytes && length > 0) {
-    assert(length <= sizeof(buffer.bytes) &&
-           "Storing too many bytes in a RegisterValue.");
     m_type = eTypeBytes;
-    buffer.length = length;
-    memcpy(buffer.bytes, bytes, length);
+    buffer.bytes.resize(length);
+    memcpy(buffer.bytes.data(), bytes, length);
     buffer.byte_order = byte_order;
   } else {
     m_type = eTypeInvalid;
-    buffer.length = 0;
+    buffer.bytes.resize(0);
   }
 }
 
 bool RegisterValue::operator==(const RegisterValue &rhs) const {
   if (m_type == rhs.m_type) {
     switch (m_type) {
     case eTypeInvalid:
       return true;
     case eTypeUInt8:
     case eTypeUInt16:
     case eTypeUInt32:
     case eTypeUInt64:
     case eTypeUInt128:
     case eTypeFloat:
     case eTypeDouble:
     case eTypeLongDouble:
       return m_scalar == rhs.m_scalar;
     case eTypeBytes:
-      if (buffer.length != rhs.buffer.length)
-        return false;
-      else {
-        uint16_t length = buffer.length;
-        if (length > kMaxRegisterByteSize)
-          length = kMaxRegisterByteSize;
-        return memcmp(buffer.bytes, rhs.buffer.bytes, length) == 0;
-      }
-      break;
+      return buffer.bytes == rhs.buffer.bytes;
     }
   }
   return false;
 }
 
 bool RegisterValue::operator!=(const RegisterValue &rhs) const {
   return !(*this == rhs);
 }
bool RegisterValue::ClearBit(uint32_t bit) {
   case eTypeLongDouble:
     break;
 
   case eTypeBytes:
     if (buffer.byte_order == eByteOrderBig ||
         buffer.byte_order == eByteOrderLittle) {
       uint32_t byte_idx;
       if (buffer.byte_order == eByteOrderBig)
-        byte_idx = buffer.length - (bit / 8) - 1;
+        byte_idx = buffer.bytes.size() - (bit / 8) - 1;
       else
         byte_idx = bit / 8;
 
       const uint32_t byte_bit = bit % 8;
-      if (byte_idx < buffer.length) {
+      if (byte_idx < buffer.bytes.size()) {
         buffer.bytes[byte_idx] &= ~(1u << byte_bit);
         return true;
       }
     }
     break;
   }
   return false;
 }
bool RegisterValue::SetBit(uint32_t bit) {
   case eTypeLongDouble:
     break;
 
   case eTypeBytes:
     if (buffer.byte_order == eByteOrderBig ||
         buffer.byte_order == eByteOrderLittle) {
       uint32_t byte_idx;
       if (buffer.byte_order == eByteOrderBig)
-        byte_idx = buffer.length - (bit / 8) - 1;
+        byte_idx = buffer.bytes.size() - (bit / 8) - 1;
       else
         byte_idx = bit / 8;
 
       const uint32_t byte_bit = bit % 8;
-      if (byte_idx < buffer.length) {
+      if (byte_idx < buffer.bytes.size()) {
         buffer.bytes[byte_idx] |= (1u << byte_bit);
         return true;
       }
     }
     break;
   }
   return false;
 }