Add MCRegister and use it in MCRegisterClass::contains()

[dsanders]

Summary

Register can cast to MCRegister and we may want to consider asserting
!isValid() || isPhysical() when expensive checks are on.

Depends on D65554

[arsenm]

llvm/include/llvm/MC/MCRegister.h

18 ↗

(On Diff #212877)

MCPhysReg?

21 ↗

(On Diff #212877)

MCPhysReg?

53 ↗

(On Diff #212877)

I would expect this to be trivially true?

[dsanders]

llvm/include/llvm/MC/MCRegister.h

18 ↗

(On Diff #212877)

I didn't want to change the size but also I didn't want to change the sentinel values for DenseMapInfo which are 0xFFFFFFFF and 0xFFFFFFFE.

53 ↗

(On Diff #212877)

It's false for 0 ($noreg) and illegal values. If neither isValid() or isPhysical() are true then something is leaking illegal values into the MC layer.

[arsenm]

LGTM

llvm/trunk/include/llvm/CodeGen/Register.h

public:
   unsigned virtRegIndex() const {
     return virtReg2Index(Reg);
   }
 
   operator unsigned() const {
     return Reg;
   }
 
+  operator MCRegister() const {
+    return MCRegister(Reg);
+  }
+
   bool isValid() const {
     return Reg != 0;
   }
 };
 
 }
 
 #endif // ifndef LLVM_CODEGEN_REGISTER_H

llvm/trunk/include/llvm/MC/MCRegister.h

 //===-- llvm/MC/Register.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 LLVM_MC_REGISTER_H
 #define LLVM_MC_REGISTER_H
 
 #include <cassert>
 
 namespace llvm {
 
 /// Wrapper class representing physical registers. Should be passed by value.
-/// Note that this class is not fully implemented at this time. A more complete
-/// implementation will follow.
 class MCRegister {
+  unsigned Reg;
+
 public:
+  MCRegister(unsigned Val = 0): Reg(Val) {}
+
   // Register numbers can represent physical registers, virtual registers, and
   // sometimes stack slots. The unsigned values are divided into these ranges:
   //
   //   0           Not a register, can be used as a sentinel.
   //   [1;2^30)    Physical registers assigned by TableGen.
   //   [2^30;2^31) Stack slots. (Rarely used.)
   //   [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
   //
public:
   }
 
   /// Return true if the specified register number is in
   /// the physical register namespace.
   static bool isPhysicalRegister(unsigned Reg) {
     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
     return int(Reg) > 0;
   }
+
+  /// Return true if the specified register number is in the physical register
+  /// namespace.
+  bool isPhysical() const {
+    return isPhysicalRegister(Reg);
+  }
+
+  operator unsigned() const {
+    return Reg;
+  }
+
+  bool isValid() const {
+    return Reg != 0;
+  }
 };
 
 }
 
 #endif // ifndef LLVM_MC_REGISTER_H
-

llvm/trunk/include/llvm/MC/MCRegisterInfo.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCREGISTERINFO_H
 #define LLVM_MC_MCREGISTERINFO_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/LaneBitmask.h"
+#include "llvm/MC/MCRegister.h"
 #include <cassert>
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 /// An unsigned integer type large enough to represent all physical registers,
 /// but not necessarily virtual registers.
public:
   ///
   unsigned getRegister(unsigned i) const {
     assert(i < getNumRegs() && "Register number out of range!");
     return RegsBegin[i];
   }
 
   /// contains - Return true if the specified register is included in this
   /// register class.  This does not include virtual registers.
-  bool contains(unsigned Reg) const {
-    unsigned InByte = Reg % 8;
-    unsigned Byte = Reg / 8;
+  bool contains(MCRegister Reg) const {
+    unsigned RegNo = unsigned(Reg);
+    unsigned InByte = RegNo % 8;
+    unsigned Byte = RegNo / 8;
     if (Byte >= RegSetSize)
       return false;
     return (RegSet[Byte] & (1 << InByte)) != 0;
   }
 
   /// contains - Return true if both registers are in this class.
-  bool contains(unsigned Reg1, unsigned Reg2) const {
+  bool contains(MCRegister Reg1, MCRegister Reg2) const {
     return contains(Reg1) && contains(Reg2);
   }
 
   /// getCopyCost - Return the cost of copying a value between two registers in
   /// this class. A negative number means the register class is very expensive
   /// to copy e.g. status flag register classes.
   int getCopyCost() const { return CopyCost; }