contrib/llvm-project/llvm/include/llvm/CodeGen/Register.h

   1 //===-- llvm/CodeGen/Register.h ---------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_CODEGEN_REGISTER_H
  10 #define LLVM_CODEGEN_REGISTER_H
  11
  12 #include "llvm/MC/MCRegister.h"
  13 #include <cassert>
  14
  15 namespace llvm {
  16
  17 /// Wrapper class representing virtual and physical registers. Should be passed
  18 /// by value.
  19 class Register {
  20   unsigned Reg;
  21
  22 public:
  23   constexpr Register(unsigned Val = 0): Reg(Val) {}
  24   constexpr Register(MCRegister Val): Reg(Val) {}
  25
  26   // Register numbers can represent physical registers, virtual registers, and
  27   // sometimes stack slots. The unsigned values are divided into these ranges:
  28   //
  29   //   0           Not a register, can be used as a sentinel.
  30   //   [1;2^30)    Physical registers assigned by TableGen.
  31   //   [2^30;2^31) Stack slots. (Rarely used.)
  32   //   [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
  33   //
  34   // Further sentinels can be allocated from the small negative integers.
  35   // DenseMapInfo<unsigned> uses -1u and -2u.
  36   static_assert(std::numeric_limits<decltype(Reg)>::max() >= 0xFFFFFFFF,
  37                 "Reg isn't large enough to hold full range.");
  38
  39   /// isStackSlot - Sometimes it is useful the be able to store a non-negative
  40   /// frame index in a variable that normally holds a register. isStackSlot()
  41   /// returns true if Reg is in the range used for stack slots.
  42   ///
  43   /// Note that isVirtualRegister() and isPhysicalRegister() cannot handle stack
  44   /// slots, so if a variable may contains a stack slot, always check
  45   /// isStackSlot() first.
  46   ///
  47   static bool isStackSlot(unsigned Reg) {
  48     return MCRegister::isStackSlot(Reg);
  49   }
  50
  51   /// Compute the frame index from a register value representing a stack slot.
  52   static int stackSlot2Index(unsigned Reg) {
  53     assert(isStackSlot(Reg) && "Not a stack slot");
  54     return int(Reg - MCRegister::FirstStackSlot);
  55   }
  56
  57   /// Convert a non-negative frame index to a stack slot register value.
  58   static unsigned index2StackSlot(int FI) {
  59     assert(FI >= 0 && "Cannot hold a negative frame index.");
  60     return FI + MCRegister::FirstStackSlot;
  61   }
  62
  63   /// Return true if the specified register number is in
  64   /// the physical register namespace.
  65   static bool isPhysicalRegister(unsigned Reg) {
  66     return MCRegister::isPhysicalRegister(Reg);
  67   }
  68
  69   /// Return true if the specified register number is in
  70   /// the virtual register namespace.
  71   static bool isVirtualRegister(unsigned Reg) {
  72     assert(!isStackSlot(Reg) && "Not a register! Check isStackSlot() first.");
  73     return Reg & MCRegister::VirtualRegFlag;
  74   }
  75
  76   /// Convert a virtual register number to a 0-based index.
  77   /// The first virtual register in a function will get the index 0.
  78   static unsigned virtReg2Index(unsigned Reg) {
  79     assert(isVirtualRegister(Reg) && "Not a virtual register");
  80     return Reg & ~MCRegister::VirtualRegFlag;
  81   }
  82
  83   /// Convert a 0-based index to a virtual register number.
  84   /// This is the inverse operation of VirtReg2IndexFunctor below.
  85   static unsigned index2VirtReg(unsigned Index) {
  86     assert(Index < (1u << 31) && "Index too large for virtual register range.");
  87     return Index | MCRegister::VirtualRegFlag;
  88   }
  89
  90   /// Return true if the specified register number is in the virtual register
  91   /// namespace.
  92   bool isVirtual() const {
  93     return isVirtualRegister(Reg);
  94   }
  95
  96   /// Return true if the specified register number is in the physical register
  97   /// namespace.
  98   bool isPhysical() const {
  99     return isPhysicalRegister(Reg);
 100   }
 101
 102   /// Convert a virtual register number to a 0-based index. The first virtual
 103   /// register in a function will get the index 0.
 104   unsigned virtRegIndex() const {
 105     return virtReg2Index(Reg);
 106   }
 107
 108   constexpr operator unsigned() const {
 109     return Reg;
 110   }
 111
 112   unsigned id() const { return Reg; }
 113
 114   operator MCRegister() const {
 115     return MCRegister(Reg);
 116   }
 117
 118   bool isValid() const { return Reg != MCRegister::NoRegister; }
 119
 120   /// Comparisons between register objects
 121   bool operator==(const Register &Other) const { return Reg == Other.Reg; }
 122   bool operator!=(const Register &Other) const { return Reg != Other.Reg; }
 123   bool operator==(const MCRegister &Other) const { return Reg == Other.id(); }
 124   bool operator!=(const MCRegister &Other) const { return Reg != Other.id(); }
 125
 126   /// Comparisons against register constants. E.g.
 127   /// * R == AArch64::WZR
 128   /// * R == 0
 129   /// * R == VirtRegMap::NO_PHYS_REG
 130   bool operator==(unsigned Other) const { return Reg == Other; }
 131   bool operator!=(unsigned Other) const { return Reg != Other; }
 132   bool operator==(int Other) const { return Reg == unsigned(Other); }
 133   bool operator!=(int Other) const { return Reg != unsigned(Other); }
 134   // MSVC requires that we explicitly declare these two as well.
 135   bool operator==(MCPhysReg Other) const { return Reg == unsigned(Other); }
 136   bool operator!=(MCPhysReg Other) const { return Reg != unsigned(Other); }
 137 };
 138
 139 // Provide DenseMapInfo for Register
 140 template<> struct DenseMapInfo<Register> {
 141   static inline unsigned getEmptyKey() {
 142     return DenseMapInfo<unsigned>::getEmptyKey();
 143   }
 144   static inline unsigned getTombstoneKey() {
 145     return DenseMapInfo<unsigned>::getTombstoneKey();
 146   }
 147   static unsigned getHashValue(const Register &Val) {
 148     return DenseMapInfo<unsigned>::getHashValue(Val.id());
 149   }
 150   static bool isEqual(const Register &LHS, const Register &RHS) {
 151     return DenseMapInfo<unsigned>::isEqual(LHS.id(), RHS.id());
 152   }
 153 };
 154
 155 }
 156
 157 #endif // ifndef LLVM_CODEGEN_REGISTER_H