[lldb][AArch64] Remove bool return from UpdateARM64SVERegistersInfos

[DavidSpickett]

Summary

This always succeeds. While I'm here, document why we check the size
of p0 against the value of VG.

[omjavaid]

Thanks!

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

 //===-- GDBRemoteRegisterContext.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
typedef std::shared_ptr<GDBRemoteDynamicRegisterInfo>
     GDBRemoteDynamicRegisterInfoSP;
 
 class GDBRemoteDynamicRegisterInfo final : public DynamicRegisterInfo {
 public:
   GDBRemoteDynamicRegisterInfo() : DynamicRegisterInfo() {}
 
   ~GDBRemoteDynamicRegisterInfo() override = default;
 
-  bool UpdateARM64SVERegistersInfos(uint64_t vg);
+  void UpdateARM64SVERegistersInfos(uint64_t vg);
 };
 
 class GDBRemoteRegisterContext : public RegisterContext {
 public:
   GDBRemoteRegisterContext(ThreadGDBRemote &thread, uint32_t concrete_frame_idx,
                            GDBRemoteDynamicRegisterInfoSP reg_info_sp,
                            bool read_all_at_once, bool write_all_at_once);
 

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

 //===-- GDBRemoteRegisterContext.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
bool GDBRemoteRegisterContext::AArch64SVEReconfigure() {
   const RegisterInfo *reg_info = m_reg_info_sp->GetRegisterInfo("vg");
   if (!reg_info)
     return false;
 
   uint64_t fail_value = LLDB_INVALID_ADDRESS;
   uint32_t vg_reg_num = reg_info->kinds[eRegisterKindLLDB];
   uint64_t vg_reg_value = ReadRegisterAsUnsigned(vg_reg_num, fail_value);
 
-  if (vg_reg_value != fail_value && vg_reg_value <= 32) {
-    const RegisterInfo *reg_info = m_reg_info_sp->GetRegisterInfo("p0");
-    if (!reg_info || vg_reg_value == reg_info->byte_size)
-      return false;
+  if (vg_reg_value == fail_value || vg_reg_value > 32)
+    return false;
+
+  reg_info = m_reg_info_sp->GetRegisterInfo("p0");
+  // Predicate registers have 1 bit per byte in the vector so their size is
+  // VL / 8. VG is in units of 8 bytes already, so if the size of p0 == VG
+  // already, we do not have to reconfigure.
 
-    if (m_reg_info_sp->UpdateARM64SVERegistersInfos(vg_reg_value)) {
-      // Make a heap based buffer that is big enough to store all registers
-      m_reg_data.SetData(std::make_shared<DataBufferHeap>(
-          m_reg_info_sp->GetRegisterDataByteSize(), 0));
-      m_reg_data.SetByteOrder(GetByteOrder());
+  m_reg_info_sp->UpdateARM64SVERegistersInfos(vg_reg_value);
 
-      InvalidateAllRegisters();
 
-      return true;
-    }
-  }
 
-  return false;
-}
-
-bool GDBRemoteDynamicRegisterInfo::UpdateARM64SVERegistersInfos(uint64_t vg) {
+void GDBRemoteDynamicRegisterInfo::UpdateARM64SVERegistersInfos(uint64_t vg) {
   // SVE Z register size is vg x 8 bytes.
   uint32_t z_reg_byte_size = vg * 8;
 
   // SVE vector length has changed, accordingly set size of Z, P and FFR
   // registers. Also invalidate register offsets it will be recalculated
   // after SVE register size update.
   for (auto &reg : m_regs) {
     if (reg.value_regs == nullptr) {
       if (reg.name[0] == 'z' && isdigit(reg.name[1]))
         reg.byte_size = z_reg_byte_size;
       else if (reg.name[0] == 'p' && isdigit(reg.name[1]))
         reg.byte_size = vg;
       else if (strcmp(reg.name, "ffr") == 0)
         reg.byte_size = vg;
     }
     reg.byte_offset = LLDB_INVALID_INDEX32;
   }
 
   // Re-calculate register offsets
   ConfigureOffsets();
-  return true;
 }