[LLDB] Remove code duplication from RegisterContextPOSIX_*

[omjavaid]

Summary

This patch aims to remove multiple copies of GetByteOrder() and ConvertRegisterKindToRegisterNumber used in various versions of RegisterContextPOSIX_*.

Both register implementations are move to RegisterContext class which is parent of RegisterContextPOSIX_* classes.

Built and tested on x86_64-linux-gnu, aarch64-linux-gnu and arm-linux-gnueabihf targets.

[labath]

Looks good. Thanks.

lldb/include/lldb/Target/RegisterContext.h

public:
   // Detect the register size dynamically.
   uint32_t UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
                                      RegisterInfo *reg_info);
 
   virtual size_t GetRegisterSetCount() = 0;
 
   virtual const RegisterSet *GetRegisterSet(size_t reg_set) = 0;
 
+  virtual lldb::ByteOrder GetByteOrder();
+
   virtual bool ReadRegister(const RegisterInfo *reg_info,
                             RegisterValue &reg_value) = 0;
 
   virtual bool WriteRegister(const RegisterInfo *reg_info,
                              const RegisterValue &reg_value) = 0;
 
   virtual bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
     return false;
public:
   ///
   /// \param [in] num
   ///     A register number in the 'kind' register numbering scheme.
   ///
   /// \return
   ///     The equivalent register number in the eRegisterKindLLDB
   ///     numbering scheme, if possible, else LLDB_INVALID_REGNUM.
   virtual uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                                       uint32_t num) = 0;
+                                                       uint32_t num);
 
   // Subclasses can override these functions if desired
   virtual uint32_t NumSupportedHardwareBreakpoints();
 
   virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
 
   virtual bool ClearHardwareBreakpoint(uint32_t hw_idx);
 

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
 protected:
   struct RegInfo {
     uint32_t num_registers;
     uint32_t num_gpr_registers;
     uint32_t num_fpr_registers;
 
     uint32_t last_gpr;
     uint32_t first_fpr;
protected:
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_ARM_H

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

RegisterContextPOSIX_arm::GetRegisterSet(size_t set) {
   return nullptr;
 }
 
 const char *RegisterContextPOSIX_arm::GetRegisterName(unsigned reg) {
   assert(reg < m_reg_info.num_registers && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
 
-lldb::ByteOrder RegisterContextPOSIX_arm::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
-  lldb_private::Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
 bool RegisterContextPOSIX_arm::IsRegisterSetAvailable(size_t set_index) {
   return set_index < k_num_register_sets;
 }
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_arm::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < lldb::kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const lldb_private::RegisterInfo *reg_info =
-        GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
 protected:
   struct RegInfo {
     uint32_t num_registers;
     uint32_t num_gpr_registers;
     uint32_t num_fpr_registers;
 
     uint32_t last_gpr;
     uint32_t first_fpr;
protected:
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_ARM64_H

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

size_t RegisterContextPOSIX_arm64::GetRegisterSetCount() {
   for (size_t set = 0; set < k_num_register_sets; ++set) {
     if (IsRegisterSetAvailable(set))
       ++sets;
   }
 
   return sets;
 }
 
+bool RegisterContextPOSIX_arm64::IsRegisterSetAvailable(size_t set_index) {
+  return set_index < k_num_register_sets;
+}
+
 const lldb_private::RegisterSet *
 RegisterContextPOSIX_arm64::GetRegisterSet(size_t set) {
   if (IsRegisterSetAvailable(set)) {
     switch (m_register_info_up->m_target_arch.GetMachine()) {
     case llvm::Triple::aarch64:
     case llvm::Triple::aarch64_32:
       return &g_reg_sets_arm64[set];
     default:
       assert(false && "Unhandled target architecture.");
       return nullptr;
     }
   }
   return nullptr;
 }
 
 const char *RegisterContextPOSIX_arm64::GetRegisterName(unsigned reg) {
   assert(reg < m_reg_info.num_registers && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
-
-lldb::ByteOrder RegisterContextPOSIX_arm64::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
-  lldb_private::Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
-bool RegisterContextPOSIX_arm64::IsRegisterSetAvailable(size_t set_index) {
-  return set_index < k_num_register_sets;
-}
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_arm64::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < lldb::kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const lldb_private::RegisterInfo *reg_info =
-        GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

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

protected:
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_MIPS64_H

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

const RegisterSet *RegisterContextPOSIX_mips64::GetRegisterSet(size_t set) {
   }
 }
 
 const char *RegisterContextPOSIX_mips64::GetRegisterName(unsigned reg) {
   assert(reg < m_num_registers && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
 
-lldb::ByteOrder RegisterContextPOSIX_mips64::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = eByteOrderInvalid;
-  Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
 bool RegisterContextPOSIX_mips64::IsRegisterSetAvailable(size_t set_index) {
   size_t num_sets = GetRegisterSetCount();
 
   return (set_index < num_sets);
 }
 
 // Used when parsing DWARF and EH frame information and any other object file
 // sections that contain register numbers in them.

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
 protected:
   uint64_t
       m_gpr_powerpc[k_num_gpr_registers_powerpc]; // general purpose registers.
   uint64_t
       m_fpr_powerpc[k_num_fpr_registers_powerpc]; // floating point registers.
   uint32_t m_vmx_powerpc[k_num_vmx_registers_powerpc][4];
   std::unique_ptr<lldb_private::RegisterInfoInterface>
       m_register_info_up; // Register Info Interface (FreeBSD or Linux)
 
   // Determines if an extended register set is supported on the processor
   // running the inferior process.
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
   bool IsVMX(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool ReadVMX() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
   virtual bool WriteVMX() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_POWERPC_H

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

else
     return nullptr;
 }
 
 const char *RegisterContextPOSIX_powerpc::GetRegisterName(unsigned reg) {
   assert(reg < k_num_registers_powerpc && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
 
-lldb::ByteOrder RegisterContextPOSIX_powerpc::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = eByteOrderInvalid;
-  Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
 bool RegisterContextPOSIX_powerpc::IsRegisterSetAvailable(size_t set_index) {
   size_t num_sets = k_num_register_sets;
 
   return (set_index < num_sets);
 }
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_powerpc::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
 protected:
   // 64-bit general purpose registers.
   uint64_t m_gpr_ppc64le[k_num_gpr_registers_ppc64le];
 
   // floating-point registers including extended register.
   uint64_t m_fpr_ppc64le[k_num_fpr_registers_ppc64le];
 
   // VMX registers.
protected:
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
   bool IsVMX(unsigned reg);
 
   bool IsVSX(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_PPC64LE_H

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

else
     return nullptr;
 }
 
 const char *RegisterContextPOSIX_ppc64le::GetRegisterName(unsigned reg) {
   assert(reg < k_num_registers_ppc64le && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
 
-lldb::ByteOrder RegisterContextPOSIX_ppc64le::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = eByteOrderInvalid;
-  Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
 bool RegisterContextPOSIX_ppc64le::IsRegisterSetAvailable(size_t set_index) {
   size_t num_sets = k_num_register_sets;
 
   return (set_index < num_sets);
 }
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_ppc64le::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
 protected:
   struct RegInfo {
     uint32_t num_registers;
     uint32_t num_gpr_registers;
     uint32_t num_fpr_registers;
 
     uint32_t last_gpr;
     uint32_t first_fpr;
     uint32_t last_fpr;
   };
 
   RegInfo m_reg_info;
   std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_up;
 
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_S390X_H

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

case llvm::Triple::systemz:
       return &g_reg_sets_s390x[set];
     default:
       assert(false && "Unhandled target architecture.");
       return nullptr;
     }
   }
   return nullptr;
 }
-
-lldb::ByteOrder RegisterContextPOSIX_s390x::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = eByteOrderInvalid;
-  Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_s390x::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

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

public:
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
   size_t GetRegisterSetCount() override;
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
-  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
-                                               uint32_t num) override;
-
   // Note: prefer kernel definitions over user-land
   enum FPRType {
     eNotValid = 0,
     eFSAVE, // TODO
     eFXSAVE,
     eSOFT, // TODO
     eXSAVE
   };
protected:
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
   bool IsAVX(unsigned reg);
 
-  lldb::ByteOrder GetByteOrder();
-
   bool CopyXSTATEtoYMM(uint32_t reg, lldb::ByteOrder byte_order);
   bool CopyYMMtoXSTATE(uint32_t reg, lldb::ByteOrder byte_order);
   bool IsFPR(unsigned reg, FPRType fpr_type);
   FPRType GetFPRType();
 
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_X86_H

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

const RegisterSet *RegisterContextPOSIX_x86::GetRegisterSet(size_t set) {
   return nullptr;
 }
 
 const char *RegisterContextPOSIX_x86::GetRegisterName(unsigned reg) {
   assert(reg < m_reg_info.num_registers && "Invalid register offset.");
   return GetRegisterInfo()[reg].name;
 }
 
-lldb::ByteOrder RegisterContextPOSIX_x86::GetByteOrder() {
-  // Get the target process whose privileged thread was used for the register
-  // read.
-  lldb::ByteOrder byte_order = eByteOrderInvalid;
-  Process *process = CalculateProcess().get();
-
-  if (process)
-    byte_order = process->GetByteOrder();
-  return byte_order;
-}
-
 // Parse ymm registers and into xmm.bytes and ymmh.bytes.
 bool RegisterContextPOSIX_x86::CopyYMMtoXSTATE(uint32_t reg,
                                                lldb::ByteOrder byte_order) {
   if (!IsAVX(reg))
     return false;
 
   if (byte_order == eByteOrderLittle) {
     uint32_t reg_no = reg - m_reg_info.first_ymm;

 bool RegisterContextPOSIX_x86::IsRegisterSetAvailable(size_t set_index) {
   // Note: Extended register sets are assumed to be at the end of g_reg_sets...
   size_t num_sets = k_num_register_sets - k_num_extended_register_sets;
 
   if (GetFPRType() == eXSAVE) // ...and to start with AVX registers.
     ++num_sets;
   return (set_index < num_sets);
 }
-
-// Used when parsing DWARF and EH frame information and any other object file
-// sections that contain register numbers in them.
-uint32_t RegisterContextPOSIX_x86::ConvertRegisterKindToRegisterNumber(
-    lldb::RegisterKind kind, uint32_t num) {
-  const uint32_t num_regs = GetRegisterCount();
-
-  assert(kind < kNumRegisterKinds);
-  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
-    const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
-
-    if (reg_info->kinds[kind] == num)
-      return reg_idx;
-  }
-
-  return LLDB_INVALID_REGNUM;
-}

lldb/source/Target/RegisterContext.cpp

 
 uint32_t RegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
 
 uint32_t RegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
                                                 size_t size) {
   return LLDB_INVALID_INDEX32;
 }
 
+// Used when parsing DWARF and EH frame information and any other object file
+// sections that contain register numbers in them.
+uint32_t
+RegisterContext::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
+                                                     uint32_t num) {
+  const uint32_t num_regs = GetRegisterCount();
+
+  assert(kind < kNumRegisterKinds);
+  for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
+    const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
+
+    if (reg_info->kinds[kind] == num)
+      return reg_idx;
+  }
+
+  return LLDB_INVALID_REGNUM;
+}
+
 bool RegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { return false; }
 
 uint32_t RegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
 
 uint32_t RegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
                                                 bool read, bool write) {
   return LLDB_INVALID_INDEX32;
 }
if (error.Success()) {
       }
     }
   } else
     error.SetErrorString("invalid process");
 
   return error;
 }
 
+lldb::ByteOrder RegisterContext::GetByteOrder() {
+  // Get the target process whose privileged thread was used for the register
+  // read.
+  lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
+  lldb_private::Process *process = CalculateProcess().get();
+
+  if (process)
+    byte_order = process->GetByteOrder();
+  return byte_order;
+}
+
 bool RegisterContext::ReadAllRegisterValues(
     lldb_private::RegisterCheckpoint &reg_checkpoint) {
   return ReadAllRegisterValues(reg_checkpoint.GetData());
 }
 
 bool RegisterContext::WriteAllRegisterValues(
     const lldb_private::RegisterCheckpoint &reg_checkpoint) {
   return WriteAllRegisterValues(reg_checkpoint.GetData());