1 //===-- llvm/MC/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_MC_MCREGISTER_H 10 #define LLVM_MC_MCREGISTER_H 11 12 #include "llvm/ADT/DenseMapInfo.h" 13 #include "llvm/ADT/Hashing.h" 14 #include <cassert> 15 #include <limits> 16 17 namespace llvm { 18 19 /// An unsigned integer type large enough to represent all physical registers, 20 /// but not necessarily virtual registers. 21 using MCPhysReg = uint16_t; 22 23 /// Register units are used to compute register aliasing. Every register has at 24 /// least one register unit, but it can have more. Two registers overlap if and 25 /// only if they have a common register unit. 26 /// 27 /// A target with a complicated sub-register structure will typically have many 28 /// fewer register units than actual registers. MCRI::getNumRegUnits() returns 29 /// the number of register units in the target. 30 using MCRegUnit = unsigned; 31 32 /// Wrapper class representing physical registers. Should be passed by value. 33 class MCRegister { 34 friend hash_code hash_value(const MCRegister &); 35 unsigned Reg; 36 37 public: Reg(Val)38 constexpr MCRegister(unsigned Val = 0) : Reg(Val) {} 39 40 // Register numbers can represent physical registers, virtual registers, and 41 // sometimes stack slots. The unsigned values are divided into these ranges: 42 // 43 // 0 Not a register, can be used as a sentinel. 44 // [1;2^30) Physical registers assigned by TableGen. 45 // [2^30;2^31) Stack slots. (Rarely used.) 46 // [2^31;2^32) Virtual registers assigned by MachineRegisterInfo. 47 // 48 // Further sentinels can be allocated from the small negative integers. 49 // DenseMapInfo<unsigned> uses -1u and -2u. 50 static_assert(std::numeric_limits<decltype(Reg)>::max() >= 0xFFFFFFFF, 51 "Reg isn't large enough to hold full range."); 52 static constexpr unsigned NoRegister = 0u; 53 static constexpr unsigned FirstPhysicalReg = 1u; 54 static constexpr unsigned FirstStackSlot = 1u << 30; 55 static constexpr unsigned VirtualRegFlag = 1u << 31; 56 57 /// This is the portion of the positive number space that is not a physical 58 /// register. StackSlot values do not exist in the MC layer, see 59 /// Register::isStackSlot() for the more information on them. 60 /// isStackSlot(unsigned Reg)61 static constexpr bool isStackSlot(unsigned Reg) { 62 return FirstStackSlot <= Reg && Reg < VirtualRegFlag; 63 } 64 65 /// Return true if the specified register number is in 66 /// the physical register namespace. isPhysicalRegister(unsigned Reg)67 static constexpr bool isPhysicalRegister(unsigned Reg) { 68 return FirstPhysicalReg <= Reg && Reg < FirstStackSlot; 69 } 70 71 constexpr operator unsigned() const { return Reg; } 72 73 /// Check the provided unsigned value is a valid MCRegister. from(unsigned Val)74 static MCRegister from(unsigned Val) { 75 assert(Val == NoRegister || isPhysicalRegister(Val)); 76 return MCRegister(Val); 77 } 78 id()79 constexpr unsigned id() const { return Reg; } 80 isValid()81 constexpr bool isValid() const { return Reg != NoRegister; } 82 83 /// Comparisons between register objects 84 constexpr bool operator==(const MCRegister &Other) const { 85 return Reg == Other.Reg; 86 } 87 constexpr bool operator!=(const MCRegister &Other) const { 88 return Reg != Other.Reg; 89 } 90 91 /// Comparisons against register constants. E.g. 92 /// * R == AArch64::WZR 93 /// * R == 0 94 /// * R == VirtRegMap::NO_PHYS_REG 95 constexpr bool operator==(unsigned Other) const { return Reg == Other; } 96 constexpr bool operator!=(unsigned Other) const { return Reg != Other; } 97 constexpr bool operator==(int Other) const { return Reg == unsigned(Other); } 98 constexpr bool operator!=(int Other) const { return Reg != unsigned(Other); } 99 // MSVC requires that we explicitly declare these two as well. 100 constexpr bool operator==(MCPhysReg Other) const { 101 return Reg == unsigned(Other); 102 } 103 constexpr bool operator!=(MCPhysReg Other) const { 104 return Reg != unsigned(Other); 105 } 106 }; 107 108 // Provide DenseMapInfo for MCRegister 109 template <> struct DenseMapInfo<MCRegister> { 110 static inline unsigned getEmptyKey() { 111 return DenseMapInfo<unsigned>::getEmptyKey(); 112 } 113 static inline unsigned getTombstoneKey() { 114 return DenseMapInfo<unsigned>::getTombstoneKey(); 115 } 116 static unsigned getHashValue(const MCRegister &Val) { 117 return DenseMapInfo<unsigned>::getHashValue(Val.id()); 118 } 119 static bool isEqual(const MCRegister &LHS, const MCRegister &RHS) { 120 return DenseMapInfo<unsigned>::isEqual(LHS.id(), RHS.id()); 121 } 122 }; 123 124 inline hash_code hash_value(const MCRegister &Reg) { 125 return hash_value(Reg.id()); 126 } 127 } // namespace llvm 128 129 #endif // LLVM_MC_MCREGISTER_H 130