[lldb] [DynamicRegisterInfo] Pass name/alt_name via RegisterInfo

[mgorny]

Summary

Remove the name and alt_name parameters from AddRegister() and instead
pass them via RegisterInfo.name and .alt_name fields. This makes
the API simpler and removes some duplication.

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

public:
 
   DynamicRegisterInfo(DynamicRegisterInfo &&info);
   DynamicRegisterInfo &operator=(DynamicRegisterInfo &&info);
 
   size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
                          const lldb_private::ArchSpec &arch);
 
   void AddRegister(lldb_private::RegisterInfo &reg_info,
-                   lldb_private::ConstString &reg_name,
-                   lldb_private::ConstString &reg_alt_name,
                    lldb_private::ConstString &set_name);
 
   void Finalize(const lldb_private::ArchSpec &arch);
 
   size_t GetNumRegisters() const;
 
   size_t GetNumRegisterSets() const;
 

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

for (uint32_t i = 0; i < num_regs; ++i) {
     m_regs.push_back(reg_info);
     m_set_reg_nums[set].push_back(i);
   }
   Finalize(arch);
   return m_regs.size();
 }
 
 void DynamicRegisterInfo::AddRegister(RegisterInfo &reg_info,
-                                      ConstString &reg_name,
-                                      ConstString &reg_alt_name,
                                       ConstString &set_name) {
   assert(!m_finalized);
   const uint32_t reg_num = m_regs.size();
-  reg_info.name = reg_name.AsCString();
   assert(reg_info.name);
-  reg_info.alt_name = reg_alt_name.AsCString(nullptr);
   uint32_t i;
   if (reg_info.value_regs) {
     for (i = 0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i)
       m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]);
   }
   if (reg_info.invalidate_regs) {
     for (i = 0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i)
       m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]);

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

if (g_register_infos[2].byte_offset == 0) {
           const uint32_t first_primordial_reg =
               g_register_infos[i].value_regs[0];
           g_register_infos[i].byte_offset =
               g_register_infos[first_primordial_reg].byte_offset;
         }
       }
     }
     for (i = 0; i < num_registers; ++i) {
-      ConstString name;
-      ConstString alt_name;
-      if (g_register_infos[i].name && g_register_infos[i].name[0])
-        name.SetCString(g_register_infos[i].name);
-      if (g_register_infos[i].alt_name && g_register_infos[i].alt_name[0])
-        alt_name.SetCString(g_register_infos[i].alt_name);
-
       if (i <= 15 || i == 25)
-        AddRegister(g_register_infos[i], name, alt_name, gpr_reg_set);
+        AddRegister(g_register_infos[i], gpr_reg_set);
       else if (i <= 24)
-        AddRegister(g_register_infos[i], name, alt_name, sfp_reg_set);
+        AddRegister(g_register_infos[i], sfp_reg_set);
       else
-        AddRegister(g_register_infos[i], name, alt_name, vfp_reg_set);
+        AddRegister(g_register_infos[i], vfp_reg_set);
     }
   } else {
     // Add composite registers to our primordial registers, then.
     const size_t num_composites = llvm::array_lengthof(g_composites);
     const size_t num_dynamic_regs = GetNumRegisters();
     const size_t num_common_regs = num_registers - num_composites;
     RegisterInfo *g_comp_register_infos = g_register_infos + num_common_regs;
 
if (num_dynamic_regs == num_common_regs) {
       }
     } else {
       // Wrong number of registers.
       match = false;
     }
     // If "match" is true, then we can add extra registers.
     if (match) {
       for (i = 0; i < num_composites; ++i) {
-        ConstString name;
-        ConstString alt_name;
         const uint32_t first_primordial_reg =
             g_comp_register_infos[i].value_regs[0];
         const char *reg_name = g_register_infos[first_primordial_reg].name;
         if (reg_name && reg_name[0]) {
           for (uint32_t j = 0; j < num_dynamic_regs; ++j) {
             const RegisterInfo *reg_info = GetRegisterInfoAtIndex(j);
             // Find a matching primordial register info entry.
             if (reg_info && reg_info->name &&
                 ::strcasecmp(reg_info->name, reg_name) == 0) {
               // The name matches the existing primordial entry. Find and
               // assign the offset, and then add this composite register entry.
               g_comp_register_infos[i].byte_offset = reg_info->byte_offset;
-              name.SetCString(g_comp_register_infos[i].name);
-              AddRegister(g_comp_register_infos[i], name, alt_name,
-                          vfp_reg_set);
+              AddRegister(g_comp_register_infos[i], vfp_reg_set);
             }
           }
         }
       }
     }
   }
 }

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

if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response) ==
           reg_info.value_regs = value_regs.data();
         }
         if (!invalidate_regs.empty()) {
           invalidate_regs.push_back(LLDB_INVALID_REGNUM);
           reg_info.invalidate_regs = invalidate_regs.data();
         }
 
         reg_info.name = reg_name.AsCString();
+        reg_info.alt_name = alt_name.AsCString();
         // We have to make a temporary ABI here, and not use the GetABI because
         // this code gets called in DidAttach, when the target architecture
         // (and consequently the ABI we'll get from the process) may be wrong.
         if (ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use))
           abi_sp->AugmentRegisterInfo(reg_info);
 
-        m_register_info_sp->AddRegister(reg_info, reg_name, alt_name, set_name);
+        m_register_info_sp->AddRegister(reg_info, set_name);
       } else {
         break; // ensure exit before reg_num is incremented
       }
     } else {
       break;
     }
   }
 
feature_node.ForEachChildElementWithName(
         if (!invalidate_regs.empty()) {
           invalidate_regs.push_back(LLDB_INVALID_REGNUM);
           reg_info.invalidate_regs = invalidate_regs.data();
         }
 
         reg_num_remote = reg_info.kinds[eRegisterKindProcessPlugin] + 1;
         ++reg_num_local;
         reg_info.name = reg_name.AsCString();
+        reg_info.alt_name = alt_name.AsCString();
         if (abi_sp)
           abi_sp->AugmentRegisterInfo(reg_info);
-        dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name);
+        dyn_reg_info.AddRegister(reg_info, set_name);
 
         return true; // Keep iterating through all "reg" elements
       });
   return true;
 }
 
 } // namespace