[lldb] [ABI] Apply AugmentRegisterInfo() to DynamicRegisterInfo::Registers

[mgorny]

Summary

Call ABI::AugmentRegisterInfo() once with a vector of all defined
registers rather than calling it for every individual register. Move
and rename RemoteRegisterInfo from gdb-remote to
DynamicRegisterInfo::Register, and use this class when augmenting
registers.

[mgorny]

Add one missing call to AugmentRegisterInfo() before Finalize().

[mgorny]

Pass a vector of RemoteRegisterInfos instead of DynamicRegisterInfo class.

[labath]

I like everything except the class name. :)

I don't think it makes sense in the new location, and ideally I'd like to also use this for other plugins in the future (so that e.g. core file plugins don't have to excruciatingly list everything). Maybe we could move it into the the DynamicRegisterInfo class (as the intended use is to convert it to that eventually), and give it some generic name like Register or Descriptor or RegisterDescriptor ?

lldb/include/lldb/Target/DynamicRegisterInfo.h

96–98

What's up with this?

[mgorny]

lldb/include/lldb/Target/DynamicRegisterInfo.h

96–98

Probably leftover from the previous version. I need to double-check if no other commit requires that.

[mgorny]

Move/rename RemoteRegisterInfo to DynamicRegisterInfo::Register. Remove leftover DRI changes.

lldb/include/lldb/Target/ABI.h

 //===-- ABI.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_TARGET_ABI_H
 #define LLDB_TARGET_ABI_H
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/UnwindPlan.h"
+#include "lldb/Target/DynamicRegisterInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
 namespace llvm {
 class Type;
public:
   /// plug-ins would strip those bits.
   /// @{
   virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) { return pc; }
   virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) { return pc; }
   /// @}
 
   llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; }
 
-  virtual void AugmentRegisterInfo(RegisterInfo &info) = 0;
+  virtual void
+  AugmentRegisterInfo(std::vector<DynamicRegisterInfo::Register> &regs) = 0;
 
   virtual bool GetPointerReturnRegister(const char *&name) { return false; }
 
   static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
 
 protected:
   ABI(lldb::ProcessSP process_sp, std::unique_ptr<llvm::MCRegisterInfo> info_up)
       : m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) {

 
 private:
   ABI(const ABI &) = delete;
   const ABI &operator=(const ABI &) = delete;
 };
 
 class RegInfoBasedABI : public ABI {
 public:
-  void AugmentRegisterInfo(RegisterInfo &info) override;
+  void AugmentRegisterInfo(
+      std::vector<DynamicRegisterInfo::Register> &regs) override;
 
 protected:
   using ABI::ABI;
 
   bool GetRegisterInfoByName(llvm::StringRef name, RegisterInfo &info);
 
   virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
 };
 
 class MCBasedABI : public ABI {
 public:
-  void AugmentRegisterInfo(RegisterInfo &info) override;
+  void AugmentRegisterInfo(
+      std::vector<DynamicRegisterInfo::Register> &regs) override;
 
   /// If the register name is of the form "<from_prefix>[<number>]" then change
   /// the name to "<to_prefix>[<number>]". Otherwise, leave the name unchanged.
   static void MapRegisterName(std::string &reg, llvm::StringRef from_prefix,
                               llvm::StringRef to_prefix);
+
 protected:
   using ABI::ABI;
 
   /// Return eh_frame and dwarf numbers for the given register.
   virtual std::pair<uint32_t, uint32_t> GetEHAndDWARFNums(llvm::StringRef reg);
 
   /// Return the generic number of the given register.
   virtual uint32_t GetGenericNum(llvm::StringRef reg) = 0;

lldb/include/lldb/Target/DynamicRegisterInfo.h

 namespace lldb_private {
 
 class DynamicRegisterInfo {
 protected:
   DynamicRegisterInfo(DynamicRegisterInfo &) = default;
   DynamicRegisterInfo &operator=(DynamicRegisterInfo &) = default;
 
 public:
+  struct Register {
+    ConstString name;
+    ConstString alt_name;
+    ConstString set_name;
+    uint32_t byte_size = LLDB_INVALID_INDEX32;
+    uint32_t byte_offset = LLDB_INVALID_INDEX32;
+    lldb::Encoding encoding = lldb::eEncodingUint;
+    lldb::Format format = lldb::eFormatHex;
+    uint32_t regnum_dwarf = LLDB_INVALID_REGNUM;
+    uint32_t regnum_ehframe = LLDB_INVALID_REGNUM;
+    uint32_t regnum_generic = LLDB_INVALID_REGNUM;
+    uint32_t regnum_remote = LLDB_INVALID_REGNUM;
+    std::vector<uint32_t> value_regs;
+    std::vector<uint32_t> invalidate_regs;
+  };
+
   DynamicRegisterInfo() = default;
 
   DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
                       const lldb_private::ArchSpec &arch);
 
   virtual ~DynamicRegisterInfo() = default;
 
   DynamicRegisterInfo(DynamicRegisterInfo &&info);
public:
 
   void Clear();
 
   bool IsReconfigurable();
 
   const lldb_private::RegisterInfo *
   GetRegisterInfo(llvm::StringRef reg_name) const;
 
   typedef std::vector<lldb_private::RegisterInfo> reg_collection;
   llvm::iterator_range<reg_collection::const_iterator> registers() const {
     return llvm::iterator_range<reg_collection::const_iterator>(m_regs);
   }
 
 protected:
   // Classes that inherit from DynamicRegisterInfo can see and modify these
   typedef std::vector<lldb_private::RegisterSet> set_collection;
   typedef std::vector<uint32_t> reg_num_collection;
   typedef std::vector<reg_num_collection> set_reg_num_collection;
   typedef std::vector<lldb_private::ConstString> name_collection;

lldb/source/Plugins/ABI/AArch64/ABIAArch64.h

 //===-- AArch64.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_ABI_AARCH64_ABIAARCH64_H
 #define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIAARCH64_H
 
 #include "lldb/Target/ABI.h"
 
-class ABIAArch64: public lldb_private::MCBasedABI {
+class ABIAArch64 : public lldb_private::MCBasedABI {
 public:
   static void Initialize();
   static void Terminate();
 
   virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) override;
   virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) override;
 
 protected:
   virtual lldb::addr_t FixAddress(lldb::addr_t pc, lldb::addr_t mask) {
     return pc;
   }
 
   std::pair<uint32_t, uint32_t>
   GetEHAndDWARFNums(llvm::StringRef name) override;
 
   std::string GetMCName(std::string reg) override;
 
   uint32_t GetGenericNum(llvm::StringRef name) override;
 
-  void AugmentRegisterInfo(lldb_private::RegisterInfo &info) override;
+  void AugmentRegisterInfo(
+      std::vector<lldb_private::DynamicRegisterInfo::Register> &regs) override;
 
   using lldb_private::MCBasedABI::MCBasedABI;
 };
 #endif

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

return llvm::StringSwitch<uint32_t>(name)
       .Case("x3", LLDB_REGNUM_GENERIC_ARG4)
       .Case("x4", LLDB_REGNUM_GENERIC_ARG5)
       .Case("x5", LLDB_REGNUM_GENERIC_ARG6)
       .Case("x6", LLDB_REGNUM_GENERIC_ARG7)
       .Case("x7", LLDB_REGNUM_GENERIC_ARG8)
       .Default(LLDB_INVALID_REGNUM);
 }
 
-void ABIAArch64::AugmentRegisterInfo(lldb_private::RegisterInfo &info) {
-  lldb_private::MCBasedABI::AugmentRegisterInfo(info);
+void ABIAArch64::AugmentRegisterInfo(
+    std::vector<lldb_private::DynamicRegisterInfo::Register> &regs) {
+  lldb_private::MCBasedABI::AugmentRegisterInfo(regs);
 
+  lldb_private::ConstString sp_string{"sp"};
+  for (lldb_private::DynamicRegisterInfo::Register &info : regs) {
     // GDB sends x31 as "sp".  Add the "x31" alt_name for convenience.
-  if (!strcmp(info.name, "sp") && !info.alt_name)
-    info.alt_name = "x31";
+    if (info.name == sp_string && !info.alt_name)
+      info.alt_name.SetCString("x31");
+  }
 }

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

 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Target/DynamicRegisterInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/GDBRemote.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"

 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 namespace repro {
 class Loader;
 }
 namespace process_gdb_remote {
 
-struct RemoteRegisterInfo {
-  ConstString name;
-  ConstString alt_name;
-  ConstString set_name;
-  uint32_t byte_size = LLDB_INVALID_INDEX32;
-  uint32_t byte_offset = LLDB_INVALID_INDEX32;
-  lldb::Encoding encoding = lldb::eEncodingUint;
-  lldb::Format format = lldb::eFormatHex;
-  uint32_t regnum_dwarf = LLDB_INVALID_REGNUM;
-  uint32_t regnum_ehframe = LLDB_INVALID_REGNUM;
-  uint32_t regnum_generic = LLDB_INVALID_REGNUM;
-  uint32_t regnum_remote = LLDB_INVALID_REGNUM;
-  std::vector<uint32_t> value_regs;
-  std::vector<uint32_t> invalidate_regs;
-};
-
 class ThreadGDBRemote;
 
 class ProcessGDBRemote : public Process,
                          private GDBRemoteClientBase::ContinueDelegate {
 public:
   ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   ~ProcessGDBRemote() override;
protected:
 
   const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
                                             std::string &dispatch_queue_name);
 
   DynamicLoader *GetDynamicLoader() override;
 
   bool GetGDBServerRegisterInfoXMLAndProcess(
     ArchSpec &arch_to_use, std::string xml_filename,
-    std::vector<RemoteRegisterInfo> &registers);
+    std::vector<DynamicRegisterInfo::Register> &registers);
 
-  // Convert RemoteRegisterInfos into RegisterInfos and add to the dynamic
-  // register list.
-  void AddRemoteRegisters(std::vector<RemoteRegisterInfo> &registers,
+  // Convert DynamicRegisterInfo::Registers into RegisterInfos and add
+  // to the dynamic register list.
+  void AddRemoteRegisters(std::vector<DynamicRegisterInfo::Register> &registers,
                           const ArchSpec &arch_to_use);
   // Query remote GDBServer for register information
   bool GetGDBServerRegisterInfo(ArchSpec &arch);
 
   lldb::ModuleSP LoadModuleAtAddress(const FileSpec &file,
                                      lldb::addr_t link_map,
                                      lldb::addr_t base_addr,
                                      bool value_is_offset);

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

void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
 
   if (!arch_to_use.IsValid())
     arch_to_use = target_arch;
 
   if (GetGDBServerRegisterInfo(arch_to_use))
     return;
 
   char packet[128];
-  std::vector<RemoteRegisterInfo> registers;
+  std::vector<DynamicRegisterInfo::Register> registers;
   uint32_t reg_num = 0;
   for (StringExtractorGDBRemote::ResponseType response_type =
            StringExtractorGDBRemote::eResponse;
        response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
     const int packet_len =
         ::snprintf(packet, sizeof(packet), "qRegisterInfo%x", reg_num);
     assert(packet_len < (int)sizeof(packet));
     UNUSED_IF_ASSERT_DISABLED(packet_len);
     StringExtractorGDBRemote response;
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response) ==
         GDBRemoteCommunication::PacketResult::Success) {
       response_type = response.GetResponseType();
       if (response_type == StringExtractorGDBRemote::eResponse) {
         llvm::StringRef name;
         llvm::StringRef value;
-        RemoteRegisterInfo reg_info;
+        DynamicRegisterInfo::Register reg_info;
 
         while (response.GetNameColonValue(name, value)) {
           if (name.equals("name")) {
             reg_info.name.SetString(value);
           } else if (name.equals("alt-name")) {
             reg_info.alt_name.SetString(value);
           } else if (name.equals("bitsize")) {
             if (!value.getAsInteger(0, reg_info.byte_size))
if (arch_to_use.IsValid() &&
          arch_to_use.GetMachine() == llvm::Triple::thumb) &&
         arch_to_use.GetTriple().getVendor() == llvm::Triple::Apple)
       m_register_info_sp->HardcodeARMRegisters(from_scratch);
   } else if (target_arch.GetMachine() == llvm::Triple::arm ||
              target_arch.GetMachine() == llvm::Triple::thumb) {
     m_register_info_sp->HardcodeARMRegisters(from_scratch);
   }
 
-  // At this point, we can finalize our register info.
   m_register_info_sp->Finalize(GetTarget().GetArchitecture());
 }
 
 Status ProcessGDBRemote::WillLaunch(lldb_private::Module *module) {
   return WillLaunchOrAttach();
 }
 
 Status ProcessGDBRemote::WillAttachToProcessWithID(lldb::pid_t pid) {

 struct GdbServerTargetInfo {
   std::string arch;
   std::string osabi;
   stringVec includes;
   RegisterSetMap reg_set_map;
 };
 
 bool ParseRegisters(XMLNode feature_node, GdbServerTargetInfo &target_info,
-                    std::vector<RemoteRegisterInfo> &registers) {
+                    std::vector<DynamicRegisterInfo::Register> &registers) {
   if (!feature_node)
     return false;
 
   feature_node.ForEachChildElementWithName(
       "reg", [&target_info, &registers](const XMLNode &reg_node) -> bool {
         std::string gdb_group;
         std::string gdb_type;
-        RemoteRegisterInfo reg_info;
+        DynamicRegisterInfo::Register reg_info;
         bool encoding_set = false;
         bool format_set = false;
 
         // FIXME: we're silently ignoring invalid data here
         reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type,
                                    &encoding_set, &format_set, &reg_info](
                                       const llvm::StringRef &name,
                                       const llvm::StringRef &value) -> bool {

 } // namespace
 
 // This method fetches a register description feature xml file from
 // the remote stub and adds registers/register groupsets/architecture
 // information to the current process.  It will call itself recursively
 // for nested register definition files.  It returns true if it was able
 // to fetch and parse an xml file.
 bool ProcessGDBRemote::GetGDBServerRegisterInfoXMLAndProcess(
-    ArchSpec &arch_to_use, std::string xml_filename, std::vector<RemoteRegisterInfo> &registers) {
+    ArchSpec &arch_to_use, std::string xml_filename,
+    std::vector<DynamicRegisterInfo::Register> &registers) {
   // request the target xml file
   std::string raw;
   lldb_private::Status lldberr;
   if (!m_gdb_comm.ReadExtFeature(ConstString("features"),
                                  ConstString(xml_filename.c_str()), raw,
                                  lldberr)) {
     return false;
   }
if (xml_document.ParseMemory(raw.c_str(), raw.size(), xml_filename.c_str())) {
     }
   } else {
     return false;
   }
   return true;
 }
 
 void ProcessGDBRemote::AddRemoteRegisters(
-    std::vector<RemoteRegisterInfo> &registers, const ArchSpec &arch_to_use) {
-  // Don't use Process::GetABI, this code gets called from DidAttach, and
-  // in that context we haven't set the Target's architecture yet, so the
-  // ABI is also potentially incorrect.
-  ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use);
-
+    std::vector<DynamicRegisterInfo::Register> &registers,
+    const ArchSpec &arch_to_use) {
   std::map<uint32_t, uint32_t> remote_to_local_map;
   uint32_t remote_regnum = 0;
   for (auto it : llvm::enumerate(registers)) {
-    RemoteRegisterInfo &remote_reg_info = it.value();
+    DynamicRegisterInfo::Register &remote_reg_info = it.value();
 
     // Assign successive remote regnums if missing.
     if (remote_reg_info.regnum_remote == LLDB_INVALID_REGNUM)
       remote_reg_info.regnum_remote = remote_regnum;
 
     // Create a mapping from remote to local regnos.
     remote_to_local_map[remote_reg_info.regnum_remote] = it.index();
 
     remote_regnum = remote_reg_info.regnum_remote + 1;
   }
 
-  for (auto it : llvm::enumerate(registers)) {
-    uint32_t local_regnum = it.index();
-    RemoteRegisterInfo &remote_reg_info = it.value();
-
+  for (DynamicRegisterInfo::Register &remote_reg_info : registers) {
     auto proc_to_lldb = [&remote_to_local_map](uint32_t process_regnum) {
       auto lldb_regit = remote_to_local_map.find(process_regnum);
       return lldb_regit != remote_to_local_map.end() ? lldb_regit->second
                                                      : LLDB_INVALID_REGNUM;
     };
 
     llvm::transform(remote_reg_info.value_regs,
                     remote_reg_info.value_regs.begin(), proc_to_lldb);
     llvm::transform(remote_reg_info.invalidate_regs,
                     remote_reg_info.invalidate_regs.begin(), proc_to_lldb);
+  }
+
+  // Don't use Process::GetABI, this code gets called from DidAttach, and
+  // in that context we haven't set the Target's architecture yet, so the
+  // ABI is also potentially incorrect.
+  if (ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use))
+    abi_sp->AugmentRegisterInfo(registers);
+
+  for (auto it : llvm::enumerate(registers)) {
+    uint32_t local_regnum = it.index();
+    DynamicRegisterInfo::Register &remote_reg_info = it.value();
 
     auto regs_with_sentinel = [](std::vector<uint32_t> &vec) -> uint32_t * {
       if (!vec.empty()) {
         vec.push_back(LLDB_INVALID_REGNUM);
         return vec.data();
       }
       return nullptr;
     };
 
     struct RegisterInfo reg_info {
       remote_reg_info.name.AsCString(), remote_reg_info.alt_name.AsCString(),
           remote_reg_info.byte_size, remote_reg_info.byte_offset,
           remote_reg_info.encoding, remote_reg_info.format,
           {remote_reg_info.regnum_ehframe, remote_reg_info.regnum_dwarf,
            remote_reg_info.regnum_generic, remote_reg_info.regnum_remote,
            local_regnum},
           regs_with_sentinel(remote_reg_info.value_regs),
           regs_with_sentinel(remote_reg_info.invalidate_regs),
     };
-
-    if (abi_sp)
-      abi_sp->AugmentRegisterInfo(reg_info);
     m_register_info_sp->AddRegister(reg_info, remote_reg_info.set_name);
   };
 
   m_register_info_sp->Finalize(arch_to_use);
 }
 
 // query the target of gdb-remote for extended target information returns
 // true on success (got register definitions), false on failure (did not).
 bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
   // Make sure LLDB has an XML parser it can use first
   if (!XMLDocument::XMLEnabled())
     return false;
 
   // check that we have extended feature read support
   if (!m_gdb_comm.GetQXferFeaturesReadSupported())
     return false;
 
-  std::vector<RemoteRegisterInfo> registers;
+  std::vector<DynamicRegisterInfo::Register> registers;
   if (GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, "target.xml",
                                             registers))
     AddRemoteRegisters(registers, arch_to_use);
 
   return m_register_info_sp->GetNumRegisters() > 0;
 }
 
 llvm::Expected<LoadedModuleInfoList> ProcessGDBRemote::GetLoadedModuleList() {
if (can_use_svr4 && comm.GetQXferLibrariesSVR4ReadSupported()) {
     // main link map structure
     llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
     // FIXME: we're silently ignoring invalid data here
     if (!main_lm.empty())
       llvm::to_integer(main_lm, list.m_link_map);
 
     root_element.ForEachChildElementWithName(
         "library", [log, &list](const XMLNode &library) -> bool {
-
           LoadedModuleInfoList::LoadedModuleInfo module;
 
           // FIXME: we're silently ignoring invalid data here
           library.ForEachAttribute(
               [&module](const llvm::StringRef &name,
                         const llvm::StringRef &value) -> bool {
-
                 uint64_t uint_value = LLDB_INVALID_ADDRESS;
                 if (name == "name")
                   module.set_name(value.str());
                 else if (name == "lm") {
                   // the address of the link_map struct.
                   llvm::to_integer(value, uint_value);
                   module.set_link_map(uint_value);
                 } else if (name == "l_addr") {

lldb/source/Target/ABI.cpp

if (!target) {
     return nullptr;
   }
   std::unique_ptr<llvm::MCRegisterInfo> info_up(
       target->createMCRegInfo(triple));
   assert(info_up);
   return info_up;
 }
 
-void RegInfoBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
-  if (info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM &&
-      info.kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
-    return;
+void RegInfoBasedABI::AugmentRegisterInfo(
+    std::vector<DynamicRegisterInfo::Register> &regs) {
+  for (DynamicRegisterInfo::Register &info : regs) {
+    if (info.regnum_ehframe != LLDB_INVALID_REGNUM &&
+        info.regnum_dwarf != LLDB_INVALID_REGNUM)
+      continue;
 
     RegisterInfo abi_info;
-  if (!GetRegisterInfoByName(info.name, abi_info))
-    return;
+    if (!GetRegisterInfoByName(info.name.GetStringRef(), abi_info))
+      continue;
 
-  if (info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindEHFrame] = abi_info.kinds[eRegisterKindEHFrame];
-  if (info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindDWARF] = abi_info.kinds[eRegisterKindDWARF];
-  if (info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindGeneric] = abi_info.kinds[eRegisterKindGeneric];
+    if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
+      info.regnum_ehframe = abi_info.kinds[eRegisterKindEHFrame];
+    if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
+      info.regnum_dwarf = abi_info.kinds[eRegisterKindDWARF];
+    if (info.regnum_generic == LLDB_INVALID_REGNUM)
+      info.regnum_generic = abi_info.kinds[eRegisterKindGeneric];
+  }
 }
 
-void MCBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
+void MCBasedABI::AugmentRegisterInfo(
+    std::vector<DynamicRegisterInfo::Register> &regs) {
+  for (DynamicRegisterInfo::Register &info : regs) {
     uint32_t eh, dwarf;
-  std::tie(eh, dwarf) = GetEHAndDWARFNums(info.name);
+    std::tie(eh, dwarf) = GetEHAndDWARFNums(info.name.GetStringRef());
 
-  if (info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindEHFrame] = eh;
-  if (info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindDWARF] = dwarf;
-  if (info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM)
-    info.kinds[eRegisterKindGeneric] = GetGenericNum(info.name);
+    if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
+      info.regnum_ehframe = eh;
+    if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
+      info.regnum_dwarf = dwarf;
+    if (info.regnum_generic == LLDB_INVALID_REGNUM)
+      info.regnum_generic = GetGenericNum(info.name.GetStringRef());
+  }
 }
 
 std::pair<uint32_t, uint32_t>
 MCBasedABI::GetEHAndDWARFNums(llvm::StringRef name) {
   std::string mc_name = GetMCName(name.str());
   for (char &c : mc_name)
     c = std::toupper(c);
   int eh = -1;