[lldb] Drop RegisterInfoInterface::GetDynamicRegisterInfo

[labath]

Summary

"Dynamic register info" is a very overloaded term, and this particular
instance of it was only used for passing the information about the
"orig_[re]ax" pseudo-register on x86 through some generic code. Since
both sides of the code are x86-specific, I have replaced this with a
more direct route.

[DavidSpickett]

LGTM

I have no idea about the specific use case but less code is good.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

 //===-- NativeRegisterContextLinux_x86_64.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
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #ifndef lldb_NativeRegisterContextLinux_x86_64_h
 #define lldb_NativeRegisterContextLinux_x86_64_h
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
 #include "Plugins/Process/Utility/NativeRegisterContextDBReg_x86.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_x86.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 #include <optional>
 #include <sys/uio.h>
 
 namespace lldb_private {
 namespace process_linux {
 
private:
 
   bool CopyXSTATEtoMPX(uint32_t reg);
 
   bool CopyMPXtoXSTATE(uint32_t reg);
 
   bool IsMPX(uint32_t reg_index) const;
 
   void UpdateXSTATEforWrite(uint32_t reg_index);
+
+  RegisterContextLinux_x86 &GetRegisterInfo() const {
+    return static_cast<RegisterContextLinux_x86 &>(
+        *m_register_info_interface_up);
+  }
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_x86_64_h
 
 #endif // defined(__i386__) || defined(__x86_64__)

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

 llvm::Expected<ArchSpec>
 NativeRegisterContextLinux::DetermineArchitecture(lldb::tid_t tid) {
   return DetermineArchitectureViaGPR(
       tid, RegisterContextLinux_x86_64::GetGPRSizeStatic());
 }
 
 // NativeRegisterContextLinux_x86_64 members.
 
-static RegisterInfoInterface *
+static std::unique_ptr<RegisterContextLinux_x86>
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   if (HostInfo::GetArchitecture().GetAddressByteSize() == 4) {
     // 32-bit hosts run with a RegisterContextLinux_i386 context.
-    return new RegisterContextLinux_i386(target_arch);
+    return std::make_unique<RegisterContextLinux_i386>(target_arch);
   } else {
     assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
            "Register setting path assumes this is a 64-bit host");
     // X86_64 hosts know how to work with 64-bit and 32-bit EXEs using the
     // x86_64 register context.
-    return new RegisterContextLinux_x86_64(target_arch);
+    return std::make_unique<RegisterContextLinux_x86_64>(target_arch);
   }
 }
 
 // Return the size of the XSTATE area supported on this cpu. It is necessary to
 // allocate the full size of the area even if we do not use/recognise all of it
 // because ptrace(PTRACE_SETREGSET, NT_X86_XSTATE) will refuse to write to it if
 // we do not pass it a buffer of sufficient size. The size is always at least
 // sizeof(FPR) so that the allocated buffer can be safely cast to FPR*.
 static std::size_t GetXSTATESize() {
   unsigned int eax, ebx, ecx, edx;
   // First check whether the XSTATE are is supported at all.
   if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx) || !(ecx & bit_XSAVE))
     return sizeof(FPR);
 
   // Then fetch the maximum size of the area.
   if (!get_cpuid_count(0x0d, 0, &eax, &ebx, &ecx, &edx))
     return sizeof(FPR);
   return std::max<std::size_t>(ecx, sizeof(FPR));
 }
 
 NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextRegisterInfo(
-          native_thread, CreateRegisterInfoInterface(target_arch)),
+          native_thread, CreateRegisterInfoInterface(target_arch).release()),
       NativeRegisterContextLinux(native_thread),
       NativeRegisterContextDBReg_x86(native_thread),
       m_xstate_type(XStateType::Invalid), m_ymm_set(), m_mpx_set(),
       m_reg_info(), m_gpr_x86_64() {
   // Set up data about ranges of valid registers.
   switch (target_arch.GetMachine()) {
   case llvm::Triple::x86:
     m_reg_info.num_registers = k_num_registers_i386;
Status NativeRegisterContextLinux_x86_64::ReadAllRegisterValues(
   /** The following code is specific to Linux x86 based architectures,
    *  where the register orig_eax (32 bit)/orig_rax (64 bit) is set to
    *  -1 to solve the bug 23659, such a setting prevents the automatic
    *  decrement of the instruction pointer which was causing the SIGILL
    *  exception.
    * **/
 
   RegisterValue value((uint64_t)-1);
-  const RegisterInfo *reg_info =
-      GetRegisterInfoInterface().GetDynamicRegisterInfo("orig_eax");
-  if (reg_info == nullptr)
-    reg_info = GetRegisterInfoInterface().GetDynamicRegisterInfo("orig_rax");
-
-  if (reg_info != nullptr)
-    return DoWriteRegisterValue(reg_info->byte_offset, reg_info->name, value);
+  const RegisterInfo &info = GetRegisterInfo().GetOrigAxInfo();
+  return DoWriteRegisterValue(info.byte_offset, info.name, value);
 
   return error;
 }
 
 Status NativeRegisterContextLinux_x86_64::WriteAllRegisterValues(
     const lldb::DataBufferSP &data_sp) {
   Status error;
 

lldb/source/Plugins/Process/Utility/RegisterContextLinux_i386.h

 //===-- RegisterContextLinux_i386.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_I386_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_I386_H
 
-#include "RegisterInfoInterface.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_x86.h"
 
-class RegisterContextLinux_i386 : public lldb_private::RegisterInfoInterface {
+class RegisterContextLinux_i386
+    : public lldb_private::RegisterContextLinux_x86 {
 public:
   RegisterContextLinux_i386(const lldb_private::ArchSpec &target_arch);
 
   static size_t GetGPRSizeStatic();
   size_t GetGPRSize() const override { return GetGPRSizeStatic(); }
 
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
-
-  const std::vector<lldb_private::RegisterInfo> *
-  GetDynamicRegisterInfoP() const override;
-
-private:
-  std::vector<lldb_private::RegisterInfo> d_register_infos;
 };
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp

 
 // Include RegisterInfos_i386 to declare our g_register_infos_i386 structure.
 #define DECLARE_REGISTER_INFOS_I386_STRUCT
 #include "RegisterInfos_i386.h"
 #undef DECLARE_REGISTER_INFOS_I386_STRUCT
 
 RegisterContextLinux_i386::RegisterContextLinux_i386(
     const ArchSpec &target_arch)
-    : RegisterInfoInterface(target_arch) {
-  RegisterInfo orig_ax = {
-      "orig_eax",
+    : RegisterContextLinux_x86(
+          target_arch,
+          {"orig_eax",
            nullptr,
            sizeof(((GPR *)nullptr)->orig_eax),
            (LLVM_EXTENSION offsetof(GPR, orig_eax)),
            eEncodingUint,
            eFormatHex,
            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
             LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
            nullptr,
-      nullptr,
-  };
-  d_register_infos.push_back(orig_ax);
-}
+           nullptr}) {}
 
 size_t RegisterContextLinux_i386::GetGPRSizeStatic() { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextLinux_i386::GetRegisterInfo() const {
   switch (GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     return g_register_infos_i386;
   default:
     assert(false && "Unhandled target architecture.");
     return nullptr;
   }
 }
 
 uint32_t RegisterContextLinux_i386::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_i386) /
                                sizeof(g_register_infos_i386[0]));
 }
 
 uint32_t RegisterContextLinux_i386::GetUserRegisterCount() const {
   return static_cast<uint32_t>(k_num_user_registers_i386);
 }
-
-const std::vector<lldb_private::RegisterInfo> *
-RegisterContextLinux_i386::GetDynamicRegisterInfoP() const {
-  return &d_register_infos;
-}

lldb/source/Plugins/Process/Utility/RegisterContextLinux_s390x.h

public:
   size_t GetGPRSize() const override;
 
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
-  const std::vector<lldb_private::RegisterInfo> *
-  GetDynamicRegisterInfoP() const override;
-
 private:
   const lldb_private::RegisterInfo *m_register_info_p;
   uint32_t m_register_info_count;
   uint32_t m_user_register_count;
-  std::vector<lldb_private::RegisterInfo> d_register_infos;
 };
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterContextLinux_s390x.cpp

 
 RegisterContextLinux_s390x::RegisterContextLinux_s390x(
     const ArchSpec &target_arch)
     : lldb_private::RegisterInfoInterface(target_arch),
       m_register_info_p(GetRegisterInfoPtr(target_arch)),
       m_register_info_count(GetRegisterInfoCount(target_arch)),
       m_user_register_count(GetUserRegisterInfoCount(target_arch)) {}
 
-const std::vector<lldb_private::RegisterInfo> *
-RegisterContextLinux_s390x::GetDynamicRegisterInfoP() const {
-  return &d_register_infos;
-}
-
 const RegisterInfo *RegisterContextLinux_s390x::GetRegisterInfo() const {
   return m_register_info_p;
 }
 
 uint32_t RegisterContextLinux_s390x::GetRegisterCount() const {
   return m_register_info_count;
 }
 
 uint32_t RegisterContextLinux_s390x::GetUserRegisterCount() const {
   return m_user_register_count;
 }
 
 size_t RegisterContextLinux_s390x::GetGPRSize() const { return 0; }

lldb/source/Plugins/Process/Utility/RegisterContextLinux_x86.h

 //===-- RegisterContextLinux_i386.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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_I386_H
-#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_I386_H
+#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_X86_H
+#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_X86_H
 
 #include "RegisterInfoInterface.h"
 
-class RegisterContextLinux_i386 : public lldb_private::RegisterInfoInterface {
+namespace lldb_private {
+
+class RegisterContextLinux_x86 : public RegisterInfoInterface {
 public:
-  RegisterContextLinux_i386(const lldb_private::ArchSpec &target_arch);
+  RegisterContextLinux_x86(const ArchSpec &target_arch,
+                           RegisterInfo orig_ax_info)
+      : RegisterInfoInterface(target_arch), m_orig_ax_info(orig_ax_info) {}
 
   static size_t GetGPRSizeStatic();
   size_t GetGPRSize() const override { return GetGPRSizeStatic(); }
 
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
-  const std::vector<lldb_private::RegisterInfo> *
-  GetDynamicRegisterInfoP() const override;
+  const RegisterInfo &GetOrigAxInfo() const { return m_orig_ax_info; }
 
 private:
-  std::vector<lldb_private::RegisterInfo> d_register_infos;
+  lldb_private::RegisterInfo m_orig_ax_info;
 };
 
+} // namespace lldb_private
+
 #endif

lldb/source/Plugins/Process/Utility/RegisterContextLinux_x86_64.h

 //===-- RegisterContextLinux_x86_64.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_X86_64_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTLINUX_X86_64_H
 
-#include "RegisterInfoInterface.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_x86.h"
 
-class RegisterContextLinux_x86_64 : public lldb_private::RegisterInfoInterface {
+class RegisterContextLinux_x86_64
+    : public lldb_private::RegisterContextLinux_x86 {
 public:
   RegisterContextLinux_x86_64(const lldb_private::ArchSpec &target_arch);
 
   static size_t GetGPRSizeStatic();
   size_t GetGPRSize() const override { return GetGPRSizeStatic(); }
 
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
-  const std::vector<lldb_private::RegisterInfo> *
-  GetDynamicRegisterInfoP() const override;
-
 private:
   const lldb_private::RegisterInfo *m_register_info_p;
   uint32_t m_register_info_count;
   uint32_t m_user_register_count;
-  std::vector<lldb_private::RegisterInfo> d_register_infos;
+  lldb_private::RegisterInfo m_orig_rax_info;
 };
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterContextLinux_x86_64.cpp

static uint32_t GetUserRegisterInfoCount(const ArchSpec &target_arch) {
   default:
     assert(false && "Unhandled target architecture.");
     return 0;
   }
 }
 
 RegisterContextLinux_x86_64::RegisterContextLinux_x86_64(
     const ArchSpec &target_arch)
-    : lldb_private::RegisterInfoInterface(target_arch),
-      m_register_info_p(GetRegisterInfoPtr(target_arch)),
-      m_register_info_count(GetRegisterInfoCount(target_arch)),
-      m_user_register_count(GetUserRegisterInfoCount(target_arch)) {
-  RegisterInfo orig_ax = {
-      "orig_rax",
+    : lldb_private::RegisterContextLinux_x86(
+          target_arch,
+          {"orig_rax",
            nullptr,
            sizeof(((GPR *)nullptr)->orig_rax),
            (LLVM_EXTENSION offsetof(GPR, orig_rax)),
            eEncodingUint,
            eFormatHex,
            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
             LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
            nullptr,
-      nullptr,
-  };
-  d_register_infos.push_back(orig_ax);
-}
+           nullptr}),
+      m_register_info_p(GetRegisterInfoPtr(target_arch)),
+      m_register_info_count(GetRegisterInfoCount(target_arch)),
+      m_user_register_count(GetUserRegisterInfoCount(target_arch)) {}
 
 size_t RegisterContextLinux_x86_64::GetGPRSizeStatic() { return sizeof(GPR); }
 
-const std::vector<lldb_private::RegisterInfo> *
-RegisterContextLinux_x86_64::GetDynamicRegisterInfoP() const {
-  return &d_register_infos;
-}
-
 const RegisterInfo *RegisterContextLinux_x86_64::GetRegisterInfo() const {
   return m_register_info_p;
 }
 
 uint32_t RegisterContextLinux_x86_64::GetRegisterCount() const {
   return m_register_info_count;
 }
 
 uint32_t RegisterContextLinux_x86_64::GetUserRegisterCount() const {
   return m_user_register_count;
 }

lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h

public:
   // kept for lldb internal use only). Subclasses should override it if
   // they belongs to an architecture with lldb internal registers.
   virtual uint32_t GetUserRegisterCount() const { return GetRegisterCount(); }
 
   const lldb_private::ArchSpec &GetTargetArchitecture() const {
     return m_target_arch;
   }
 
-  virtual const lldb_private::RegisterInfo *
-  GetDynamicRegisterInfo(const char *reg_name) const {
-    const std::vector<lldb_private::RegisterInfo> *d_register_infos =
-        GetDynamicRegisterInfoP();
-    if (d_register_infos != nullptr) {
-      std::vector<lldb_private::RegisterInfo>::const_iterator pos =
-          d_register_infos->begin();
-      for (; pos < d_register_infos->end(); pos++) {
-        if (::strcmp(reg_name, pos->name) == 0)
-          return (d_register_infos->data() + (pos - d_register_infos->begin()));
-      }
-    }
-    return nullptr;
-  }
-
-  virtual const std::vector<lldb_private::RegisterInfo> *
-  GetDynamicRegisterInfoP() const {
-    return nullptr;
-  }
-
 private:
   lldb_private::ArchSpec m_target_arch;
 };
 } // namespace lldb_private
 
 #endif