Use 'enum class' instead of 'enum' in NativeRegisterContextLinux_x86_x64.

[zturner]

Thanks!

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

protected:
   size_t GetFPRSize() override;
 
   Error ReadFPR() override;
 
   Error WriteFPR() override;
 
 private:
   // Private member types.
-  enum XStateType { eXStateTypeNotValid = 0, eXStateTypeFXSAVE, eXStateTypeXSAVE };
-  enum RegSet { gpr, fpu, avx, mpx };
+  enum class XStateType { Invalid, FXSAVE, XSAVE };
+  enum class RegSet { gpr, fpu, avx, mpx };
 
   // Info about register ranges.
   struct RegInfo {
     uint32_t num_registers;
     uint32_t num_gpr_registers;
     uint32_t num_fpr_registers;
     uint32_t num_avx_registers;
     uint32_t num_mpx_registers;

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

CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   }
 }
 
 NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
     uint32_t concrete_frame_idx)
     : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
                                  CreateRegisterInfoInterface(target_arch)),
-      m_xstate_type(eXStateTypeNotValid), m_fpr(), m_iovec(), m_ymm_set(),
+      m_xstate_type(XStateType::Invalid), m_fpr(), m_iovec(), 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;
     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;
if (dst == nullptr) {
     error.SetErrorStringWithFormat("DataBufferHeap instance of size %" PRIu64
                                    " returned a null pointer",
                                    REG_CONTEXT_SIZE);
     return error;
   }
 
   ::memcpy(dst, &m_gpr_x86_64, GetRegisterInfoInterface().GetGPRSize());
   dst += GetRegisterInfoInterface().GetGPRSize();
-  if (GetXStateType() == eXStateTypeFXSAVE)
+  if (GetXStateType() == XStateType::FXSAVE)
     ::memcpy(dst, &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave));
-  else if (GetXStateType() == eXStateTypeXSAVE) {
+  else if (GetXStateType() == XStateType::XSAVE) {
     lldb::ByteOrder byte_order = GetByteOrder();
 
-    if (IsCPUFeatureAvailable(avx)) {
+    if (IsCPUFeatureAvailable(RegSet::avx)) {
       // Assemble the YMM register content from the register halves.
       for (uint32_t reg = m_reg_info.first_ymm; reg <= m_reg_info.last_ymm;
            ++reg) {
         if (!CopyXSTATEtoYMM(reg, byte_order)) {
           error.SetErrorStringWithFormat(
               "NativeRegisterContextLinux_x86_64::%s "
               "CopyXSTATEtoYMM() failed for reg num "
               "%" PRIu32,
               __FUNCTION__, reg);
           return error;
         }
       }
     }
 
-    if (IsCPUFeatureAvailable(mpx)) {
+    if (IsCPUFeatureAvailable(RegSet::mpx)) {
       for (uint32_t reg = m_reg_info.first_mpxr; reg <= m_reg_info.last_mpxc;
            ++reg) {
         if (!CopyXSTATEtoMPX(reg)) {
           error.SetErrorStringWithFormat(
               "NativeRegisterContextLinux_x86_64::%s "
               "CopyXSTATEtoMPX() failed for reg num "
               "%" PRIu32,
               __FUNCTION__, reg);
Error NativeRegisterContextLinux_x86_64::WriteAllRegisterValues(
   }
   ::memcpy(&m_gpr_x86_64, src, GetRegisterInfoInterface().GetGPRSize());
 
   error = WriteGPR();
   if (error.Fail())
     return error;
 
   src += GetRegisterInfoInterface().GetGPRSize();
-  if (GetXStateType() == eXStateTypeFXSAVE)
+  if (GetXStateType() == XStateType::FXSAVE)
     ::memcpy(&m_fpr.xstate.fxsave, src, sizeof(m_fpr.xstate.fxsave));
-  else if (GetXStateType() == eXStateTypeXSAVE)
+  else if (GetXStateType() == XStateType::XSAVE)
     ::memcpy(&m_fpr.xstate.xsave, src, sizeof(m_fpr.xstate.xsave));
 
   error = WriteFPR();
   if (error.Fail())
     return error;
 
-  if (GetXStateType() == eXStateTypeXSAVE) {
+  if (GetXStateType() == XStateType::XSAVE) {
     lldb::ByteOrder byte_order = GetByteOrder();
 
-    if (IsCPUFeatureAvailable(avx)) {
+    if (IsCPUFeatureAvailable(RegSet::avx)) {
       // Parse the YMM register content from the register halves.
       for (uint32_t reg = m_reg_info.first_ymm; reg <= m_reg_info.last_ymm;
            ++reg) {
         if (!CopyYMMtoXSTATE(reg, byte_order)) {
           error.SetErrorStringWithFormat(
               "NativeRegisterContextLinux_x86_64::%s "
               "CopyYMMtoXSTATE() failed for reg num "
               "%" PRIu32,
               __FUNCTION__, reg);
           return error;
         }
       }
     }
 
-    if (IsCPUFeatureAvailable(mpx)) {
+    if (IsCPUFeatureAvailable(RegSet::mpx)) {
       for (uint32_t reg = m_reg_info.first_mpxr; reg <= m_reg_info.last_mpxc;
            ++reg) {
         if (!CopyMPXtoXSTATE(reg)) {
           error.SetErrorStringWithFormat(
               "NativeRegisterContextLinux_x86_64::%s "
               "CopyMPXtoXSTATE() failed for reg num "
               "%" PRIu32,
               __FUNCTION__, reg);
           return error;
         }
       }
     }
   }
 
   return error;
 }
 
 bool NativeRegisterContextLinux_x86_64::HasFXSAVE() const {
   unsigned int rax, rbx, rcx, rdx;
 
   // Check if FXSAVE is enabled.
   if (!__get_cpuid(1, &rax, &rbx, &rcx, &rdx))
     return false;
   if ((rdx & bit_FXSAVE) == bit_FXSAVE) {
-    m_xstate_type = eXStateTypeFXSAVE;
+    m_xstate_type = XStateType::FXSAVE;
     if (const_cast<NativeRegisterContextLinux_x86_64 *>(this)->ReadFPR().Fail())
       return false;
     return true;
   }
   return false;
 }
 
 bool NativeRegisterContextLinux_x86_64::HasXSAVE() const {
   unsigned int rax, rbx, rcx, rdx;
 
   // Check if XSAVE is enabled.
   if (!__get_cpuid(1, &rax, &rbx, &rcx, &rdx))
     return false;
   if ((rcx & bit_OSXSAVE) == bit_OSXSAVE) {
-    m_xstate_type = eXStateTypeXSAVE;
+    m_xstate_type = XStateType::XSAVE;
     if (const_cast<NativeRegisterContextLinux_x86_64 *>(this)->ReadFPR().Fail())
       return false;
     return true;
   }
   return false;
 }
 
 bool NativeRegisterContextLinux_x86_64::IsCPUFeatureAvailable(
     RegSet feature_code) const {
   unsigned int rax, rbx, rcx, rdx;
 
   // Check if XSAVE is enabled.
   if (!HasXSAVE())
     return false;
 
   __get_cpuid(1, &rax, &rbx, &rcx, &rdx);
   switch (feature_code) {
-  case avx: // Check if CPU has AVX and if there is kernel support, by reading in the XCR0 area of XSAVE.
+  case RegSet::avx: // Check if CPU has AVX and if there is kernel support, by reading in the XCR0 area of XSAVE.
     if (((rcx & bit_AVX) != 0) && ((m_fpr.xstate.xsave.i387.xcr0 & mask_XSTATE_AVX) == mask_XSTATE_AVX))
       return true;
-  case mpx: // Check if CPU has MPX and if there is kernel support, by reading in the XCR0 area of XSAVE.
+  case RegSet::mpx: // Check if CPU has MPX and if there is kernel support, by reading in the XCR0 area of XSAVE.
     if (__get_cpuid_max(0, NULL) > 7) {
       __cpuid_count(7, 0, rax, rbx, rcx, rdx);
       if (((rbx & bit_MPX) != 0) && ((m_fpr.xstate.xsave.i387.xcr0 & mask_XSTATE_MPX) == mask_XSTATE_MPX))
         return true;
     }
   default:
     return false;
   }
 }
 
 bool NativeRegisterContextLinux_x86_64::IsRegisterSetAvailable(
     uint32_t set_index) const {
   uint32_t num_sets = k_num_register_sets - k_num_extended_register_sets;
 
-  switch (set_index) {
-  case gpr:
-  case fpu:
+  switch (static_cast<RegSet>(set_index)) {
+  case RegSet::gpr:
+  case RegSet::fpu:
     return (set_index < num_sets);
-  case avx:
-    return IsCPUFeatureAvailable(avx);
-  case mpx:
-    return IsCPUFeatureAvailable(mpx);
+  case RegSet::avx:
+    return IsCPUFeatureAvailable(RegSet::avx);
+  case RegSet::mpx:
+    return IsCPUFeatureAvailable(RegSet::mpx);
   default:
     return false;
   }
 }
 
 bool NativeRegisterContextLinux_x86_64::IsGPR(uint32_t reg_index) const {
   // GPRs come first.
   return reg_index <= m_reg_info.last_gpr;
 }
 
 NativeRegisterContextLinux_x86_64::XStateType
 NativeRegisterContextLinux_x86_64::GetXStateType() const {
-  if (m_xstate_type == eXStateTypeNotValid) {
+  if (m_xstate_type == XStateType::Invalid) {
     if (HasXSAVE())
-      m_xstate_type = eXStateTypeXSAVE;
+      m_xstate_type = XStateType::XSAVE;
     else if (HasFXSAVE())
-      m_xstate_type = eXStateTypeFXSAVE;
+      m_xstate_type = XStateType::FXSAVE;
   }
   return m_xstate_type;
 }
 
 bool NativeRegisterContextLinux_x86_64::IsFPR(uint32_t reg_index) const {
   return (m_reg_info.first_fpr <= reg_index &&
           reg_index <= m_reg_info.last_fpr);
 }
 
 Error NativeRegisterContextLinux_x86_64::WriteFPR() {
   const XStateType fpr_type = GetXStateType();
   const lldb_private::ArchSpec &target_arch =
       GetRegisterInfoInterface().GetTargetArchitecture();
   switch (fpr_type) {
-  case XStateType::eXStateTypeFXSAVE:
+  case XStateType::FXSAVE:
     // For 32-bit inferiors on x86_32/x86_64 architectures,
     // FXSAVE area can be written using PTRACE_SETREGSET ptrace api
     // For 64-bit inferiors on x86_64 architectures,
     // FXSAVE area can be written using PTRACE_SETFPREGS ptrace api
     switch (target_arch.GetMachine()) {
     case llvm::Triple::x86:
       return WriteRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave),
                               NT_PRXFPREG);
     case llvm::Triple::x86_64:
       return NativeRegisterContextLinux::WriteFPR();
     default:
       assert(false && "Unhandled target architecture.");
       break;
     }
-  case XStateType::eXStateTypeXSAVE:
+  case XStateType::XSAVE:
     return WriteRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave),
                             NT_X86_XSTATE);
   default:
     return Error("Unrecognized FPR type");
   }
 }
 
 bool NativeRegisterContextLinux_x86_64::IsAVX(uint32_t reg_index) const {
-  if (!IsCPUFeatureAvailable(avx))
+  if (!IsCPUFeatureAvailable(RegSet::avx))
     return false;
   return (m_reg_info.first_ymm <= reg_index &&
           reg_index <= m_reg_info.last_ymm);
 }
 
 bool NativeRegisterContextLinux_x86_64::CopyXSTATEtoYMM(
     uint32_t reg_index, lldb::ByteOrder byte_order) {
   if (!IsAVX(reg_index))
if (byte_order == lldb::eByteOrderBig) {
     return true;
   }
   return false; // unsupported or invalid byte order
 }
 
 void *NativeRegisterContextLinux_x86_64::GetFPRBuffer() {
   const XStateType xstate_type = GetXStateType();
   switch (xstate_type) {
-  case XStateType::eXStateTypeFXSAVE:
+  case XStateType::FXSAVE:
     return &m_fpr.xstate.fxsave;
-  case XStateType::eXStateTypeXSAVE:
+  case XStateType::XSAVE:
     return &m_iovec;
   default:
     return nullptr;
   }
 }
 
 size_t NativeRegisterContextLinux_x86_64::GetFPRSize() {
   const XStateType xstate_type = GetXStateType();
   switch (xstate_type) {
-  case XStateType::eXStateTypeFXSAVE:
+  case XStateType::FXSAVE:
     return sizeof(m_fpr.xstate.fxsave);
-  case XStateType::eXStateTypeXSAVE:
+  case XStateType::XSAVE:
     return sizeof(m_iovec);
   default:
     return 0;
   }
 }
 
 Error NativeRegisterContextLinux_x86_64::ReadFPR() {
   const XStateType xstate_type = GetXStateType();
   const lldb_private::ArchSpec &target_arch =
       GetRegisterInfoInterface().GetTargetArchitecture();
   switch (xstate_type) {
-  case XStateType::eXStateTypeFXSAVE:
+  case XStateType::FXSAVE:
     // For 32-bit inferiors on x86_32/x86_64 architectures,
     // FXSAVE area can be read using PTRACE_GETREGSET ptrace api
     // For 64-bit inferiors on x86_64 architectures,
     // FXSAVE area can be read using PTRACE_GETFPREGS ptrace api
     switch (target_arch.GetMachine()) {
     case llvm::Triple::x86:
       return ReadRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_PRXFPREG);
     case llvm::Triple::x86_64:
       return NativeRegisterContextLinux::ReadFPR();
     default:
       assert(false && "Unhandled target architecture.");
       break;
     }
-  case XStateType::eXStateTypeXSAVE:
+  case XStateType::XSAVE:
     return ReadRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE);
   default:
     return Error("Unrecognized FPR type");
   }
 }
 
 bool NativeRegisterContextLinux_x86_64::IsMPX(uint32_t reg_index) const {
-  if (!IsCPUFeatureAvailable(mpx))
+  if (!IsCPUFeatureAvailable(RegSet::mpx))
     return false;
   return (m_reg_info.first_mpxr <= reg_index &&
           reg_index <= m_reg_info.last_mpxc);
 }
 
 bool NativeRegisterContextLinux_x86_64::CopyXSTATEtoMPX(uint32_t reg) {
   if (!IsMPX(reg))
     return false;