[LLDB] Fix: make m_target_arch private

[Emmmer]

Summary

Using GetTargetArchitecture() instead of m_target_arch, and set m_target_arch to private.

[DavidSpickett]

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

224–225

Please also remove the commented out asserts that use m_target_arch.

At least for PowerPC they have been commented out since the first commit so it won't do any harm to remove them and they will now fail to compile anyway.

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

64

Rare footage of a fixme getting fixed :) Thanks!

[Emmmer]

Address review comments

[DavidSpickett]

I think there are a few more commented out asserts, check that a grep for m_target_arch in lldb/ doesn't turn up anything you wouldn't expect.

Otherwise LGTM. If you find any more just land it with them removed.

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

 
 RegisterContextFreeBSD_i386::RegisterContextFreeBSD_i386(
     const ArchSpec &target_arch)
     : RegisterInfoInterface(target_arch) {}
 
 size_t RegisterContextFreeBSD_i386::GetGPRSize() const { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextFreeBSD_i386::GetRegisterInfo() const {
-  switch (m_target_arch.GetMachine()) {
+  switch (GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
     return g_register_infos_i386;
   default:
     assert(false && "Unhandled target architecture.");
     return nullptr;
   }
 }
 
 uint32_t RegisterContextFreeBSD_i386::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_i386) /
                                sizeof(g_register_infos_i386[0]));
 }

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

RegisterContextFreeBSD_mips64::GetRegisterSet(size_t set) const {
   return nullptr;
 }
 
 size_t RegisterContextFreeBSD_mips64::GetRegisterSetCount() const {
   return k_num_register_sets;
 }
 
 const RegisterInfo *RegisterContextFreeBSD_mips64::GetRegisterInfo() const {
-  assert(m_target_arch.GetCore() == ArchSpec::eCore_mips64);
+  assert(GetTargetArchitecture().GetCore() == ArchSpec::eCore_mips64);
   return g_register_infos_mips64;
 }
 
 uint32_t RegisterContextFreeBSD_mips64::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_mips64) /
                                sizeof(g_register_infos_mips64[0]));
 }

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

 RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc() = default;
 
 size_t RegisterContextFreeBSD_powerpc::GetGPRSize() const {
   // This is an 'abstract' base, so no GPR struct.
   return 0;
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc::GetRegisterInfo() const {
-  // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
   llvm_unreachable("Abstract class!");
   return nullptr;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc::GetRegisterCount() const { return 0; }
 
 RegisterContextFreeBSD_powerpc32::RegisterContextFreeBSD_powerpc32(
     const ArchSpec &target_arch)
     : RegisterContextFreeBSD_powerpc(target_arch) {}
 
 RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32() = default;
 
 size_t RegisterContextFreeBSD_powerpc32::GetGPRSize() const {
   return sizeof(GPR32);
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc32::GetRegisterInfo() const {
-  // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
   return g_register_infos_powerpc32;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc32::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_powerpc32) /
                                sizeof(g_register_infos_powerpc32[0]));
 }
 
 RegisterContextFreeBSD_powerpc64::RegisterContextFreeBSD_powerpc64(
     const ArchSpec &target_arch)
     : RegisterContextFreeBSD_powerpc(target_arch) {}
 
 RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64() = default;
 
 size_t RegisterContextFreeBSD_powerpc64::GetGPRSize() const {
   return sizeof(GPR64);
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc64::GetRegisterInfo() const {
-  // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
-  if (m_target_arch.GetMachine() == llvm::Triple::ppc)
+  if (GetTargetArchitecture().GetMachine() == llvm::Triple::ppc)
     return g_register_infos_powerpc64_32;
   return g_register_infos_powerpc64;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc64::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_powerpc64) /
                                sizeof(g_register_infos_powerpc64[0]));
 }

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

RegisterInfo orig_ax = {
       nullptr,
   };
   d_register_infos.push_back(orig_ax);
 }
 
 size_t RegisterContextLinux_i386::GetGPRSizeStatic() { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextLinux_i386::GetRegisterInfo() const {
-  switch (m_target_arch.GetMachine()) {
+  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;
   }
 }

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

 
 RegisterContextNetBSD_i386::RegisterContextNetBSD_i386(
     const ArchSpec &target_arch)
     : RegisterInfoInterface(target_arch) {}
 
 size_t RegisterContextNetBSD_i386::GetGPRSize() const { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextNetBSD_i386::GetRegisterInfo() const {
-  switch (m_target_arch.GetMachine()) {
+  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 RegisterContextNetBSD_i386::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_i386) /
                                sizeof(g_register_infos_i386[0]));
 }

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

 
 RegisterContextOpenBSD_i386::RegisterContextOpenBSD_i386(
     const ArchSpec &target_arch)
     : RegisterInfoInterface(target_arch) {}
 
 size_t RegisterContextOpenBSD_i386::GetGPRSize() const { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextOpenBSD_i386::GetRegisterInfo() const {
-  switch (m_target_arch.GetMachine()) {
+  switch (GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
     return g_register_infos_i386;
   default:
     assert(false && "Unhandled target architecture.");
     return nullptr;
   }
 }
 
 uint32_t RegisterContextOpenBSD_i386::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_i386) /
                                sizeof(g_register_infos_i386[0]));
 }

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

 }
 
 RegisterContextPOSIX_s390x::RegisterContextPOSIX_s390x(
     Thread &thread, uint32_t concrete_frame_idx,
     RegisterInfoInterface *register_info)
     : RegisterContext(thread, concrete_frame_idx) {
   m_register_info_up.reset(register_info);
 
-  switch (register_info->m_target_arch.GetMachine()) {
+  switch (register_info->GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::systemz:
     m_reg_info.num_registers = k_num_registers_s390x;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_s390x;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_s390x;
     m_reg_info.last_gpr = k_last_gpr_s390x;
     m_reg_info.first_fpr = k_first_fpr_s390x;
     m_reg_info.last_fpr = k_last_fpr_s390x;
     break;
if (IsRegisterSetAvailable(set))
       ++sets;
   }
 
   return sets;
 }
 
 const RegisterSet *RegisterContextPOSIX_s390x::GetRegisterSet(size_t set) {
   if (IsRegisterSetAvailable(set)) {
-    switch (m_register_info_up->m_target_arch.GetMachine()) {
+    switch (m_register_info_up->GetTargetArchitecture().GetMachine()) {
     case llvm::Triple::systemz:
       return &g_reg_sets_s390x[set];
     default:
       assert(false && "Unhandled target architecture.");
       return nullptr;
     }
   }
   return nullptr;
 }

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

 }
 
 RegisterContextPOSIX_x86::RegisterContextPOSIX_x86(
     Thread &thread, uint32_t concrete_frame_idx,
     RegisterInfoInterface *register_info)
     : RegisterContext(thread, concrete_frame_idx) {
   m_register_info_up.reset(register_info);
 
-  switch (register_info->m_target_arch.GetMachine()) {
+  switch (register_info->GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
     m_reg_info.num_registers = k_num_registers_i386;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_i386;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_i386;
     m_reg_info.num_avx_registers = k_num_avx_registers_i386;
     m_reg_info.last_gpr = k_last_gpr_i386;
     m_reg_info.first_fpr = k_first_fpr_i386;
     m_reg_info.last_fpr = k_last_fpr_i386;
if (IsRegisterSetAvailable(set))
       ++sets;
   }
 
   return sets;
 }
 
 const RegisterSet *RegisterContextPOSIX_x86::GetRegisterSet(size_t set) {
   if (IsRegisterSetAvailable(set)) {
-    switch (m_register_info_up->m_target_arch.GetMachine()) {
+    switch (m_register_info_up->GetTargetArchitecture().GetMachine()) {
     case llvm::Triple::x86:
       return &g_reg_sets_i386[set];
     case llvm::Triple::x86_64:
       return &g_reg_sets_x86_64[set];
     default:
       assert(false && "Unhandled target architecture.");
       return nullptr;
     }

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

GetDynamicRegisterInfo(const char *reg_name) const {
     return nullptr;
   }
 
   virtual const std::vector<lldb_private::RegisterInfo> *
   GetDynamicRegisterInfoP() const {
     return nullptr;
   }
 
-  // FIXME make private.
+private:
   lldb_private::ArchSpec m_target_arch;
 };
-}
+} // namespace lldb_private
 
 #endif