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.id()) {} 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 to 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 /// FIXME: remove in favor of member. 44 static constexpr bool isStackSlot(unsigned Reg) { 45 return MCRegister::isStackSlot(Reg); 46 } 47 48 /// Return true if this is a stack slot. 49 constexpr bool isStack() const { return MCRegister::isStackSlot(Reg); } 50 51 /// Compute the frame index from a register value representing a stack slot. 52 static int stackSlot2Index(Register Reg) { 53 assert(Reg.isStack() && "Not a stack slot"); 54 return int(Reg.id() - MCRegister::FirstStackSlot); 55 } 56 57 /// Convert a non-negative frame index to a stack slot register value. 58 static Register index2StackSlot(int FI) { 59 assert(FI >= 0 && "Cannot hold a negative frame index."); 60 return Register(FI + MCRegister::FirstStackSlot); 61 } 62 63 /// Return true if the specified register number is in 64 /// the physical register namespace. 65 static constexpr 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 constexpr bool isVirtualRegister(unsigned Reg) { 72 return Reg & MCRegister::VirtualRegFlag; 73 } 74 75 /// Convert a virtual register number to a 0-based index. 76 /// The first virtual register in a function will get the index 0. 77 static unsigned virtReg2Index(Register Reg) { 78 assert(Reg.isVirtual() && "Not a virtual register"); 79 return Reg.id() & ~MCRegister::VirtualRegFlag; 80 } 81 82 /// Convert a 0-based index to a virtual register number. 83 /// This is the inverse operation of VirtReg2IndexFunctor below. 84 static Register index2VirtReg(unsigned Index) { 85 assert(Index < (1u << 31) && "Index too large for virtual register range."); 86 return Index | MCRegister::VirtualRegFlag; 87 } 88 89 /// Return true if the specified register number is in the virtual register 90 /// namespace. 91 constexpr bool isVirtual() const { return isVirtualRegister(Reg); } 92 93 /// Return true if the specified register number is in the physical register 94 /// namespace. 95 constexpr bool isPhysical() const { return isPhysicalRegister(Reg); } 96 97 /// Convert a virtual register number to a 0-based index. The first virtual 98 /// register in a function will get the index 0. 99 unsigned virtRegIndex() const { return virtReg2Index(Reg); } 100 101 constexpr operator unsigned() const { return Reg; } 102 103 constexpr unsigned id() const { return Reg; } 104 105 constexpr operator MCRegister() const { return MCRegister(Reg); } 106 107 /// Utility to check-convert this value to a MCRegister. The caller is 108 /// expected to have already validated that this Register is, indeed, 109 /// physical. 110 MCRegister asMCReg() const { 111 assert(!isValid() || isPhysical()); 112 return MCRegister(Reg); 113 } 114 115 constexpr bool isValid() const { return Reg != MCRegister::NoRegister; } 116 117 /// Comparisons between register objects 118 constexpr bool operator==(const Register &Other) const { 119 return Reg == Other.Reg; 120 } 121 constexpr bool operator!=(const Register &Other) const { 122 return Reg != Other.Reg; 123 } 124 constexpr bool operator==(const MCRegister &Other) const { 125 return Reg == Other.id(); 126 } 127 constexpr bool operator!=(const MCRegister &Other) const { 128 return Reg != Other.id(); 129 } 130 131 /// Comparisons against register constants. E.g. 132 /// * R == AArch64::WZR 133 /// * R == 0 134 constexpr bool operator==(unsigned Other) const { return Reg == Other; } 135 constexpr bool operator!=(unsigned Other) const { return Reg != Other; } 136 constexpr bool operator==(int Other) const { return Reg == unsigned(Other); } 137 constexpr bool operator!=(int Other) const { return Reg != unsigned(Other); } 138 // MSVC requires that we explicitly declare these two as well. 139 constexpr bool operator==(MCPhysReg Other) const { 140 return Reg == unsigned(Other); 141 } 142 constexpr bool operator!=(MCPhysReg Other) const { 143 return Reg != unsigned(Other); 144 } 145 }; 146 147 // Provide DenseMapInfo for Register 148 template <> struct DenseMapInfo<Register> { 149 static inline Register getEmptyKey() { 150 return DenseMapInfo<unsigned>::getEmptyKey(); 151 } 152 static inline Register getTombstoneKey() { 153 return DenseMapInfo<unsigned>::getTombstoneKey(); 154 } 155 static unsigned getHashValue(const Register &Val) { 156 return DenseMapInfo<unsigned>::getHashValue(Val.id()); 157 } 158 static bool isEqual(const Register &LHS, const Register &RHS) { 159 return LHS == RHS; 160 } 161 }; 162 163 /// Wrapper class representing a virtual register or register unit. 164 class VirtRegOrUnit { 165 unsigned VRegOrUnit; 166 167 public: 168 constexpr explicit VirtRegOrUnit(MCRegUnit Unit) : VRegOrUnit(Unit) { 169 assert(!Register::isVirtualRegister(VRegOrUnit)); 170 } 171 constexpr explicit VirtRegOrUnit(Register Reg) : VRegOrUnit(Reg.id()) { 172 assert(Reg.isVirtual()); 173 } 174 175 constexpr bool isVirtualReg() const { 176 return Register::isVirtualRegister(VRegOrUnit); 177 } 178 179 constexpr MCRegUnit asMCRegUnit() const { 180 assert(!isVirtualReg() && "Not a register unit"); 181 return VRegOrUnit; 182 } 183 184 constexpr Register asVirtualReg() const { 185 assert(isVirtualReg() && "Not a virtual register"); 186 return Register(VRegOrUnit); 187 } 188 189 constexpr bool operator==(const VirtRegOrUnit &Other) const { 190 return VRegOrUnit == Other.VRegOrUnit; 191 } 192 }; 193 194 } // namespace llvm 195 196 #endif // LLVM_CODEGEN_REGISTER_H 197