LLVM 20.0.0git
MCRegister.h
Go to the documentation of this file.
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
13#include "llvm/ADT/Hashing.h"
14#include <cassert>
15#include <limits>
16
17namespace llvm {
18
19/// An unsigned integer type large enough to represent all physical registers,
20/// but not necessarily virtual registers.
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.
31
32/// Wrapper class representing physical registers. Should be passed by value.
34 friend hash_code hash_value(const MCRegister &);
35 unsigned Reg;
36
37public:
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 ///
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.
67 static constexpr bool isPhysicalRegister(unsigned Reg) {
68 return FirstPhysicalReg <= Reg && Reg < FirstStackSlot;
69 }
70
71 /// Return true if the specified register number is in the physical register
72 /// namespace.
73 constexpr bool isPhysical() const { return isPhysicalRegister(Reg); }
74
75 constexpr operator unsigned() const { return Reg; }
76
77 /// Check the provided unsigned value is a valid MCRegister.
78 static MCRegister from(unsigned Val) {
79 assert(Val == NoRegister || isPhysicalRegister(Val));
80 return MCRegister(Val);
81 }
82
83 constexpr unsigned id() const { return Reg; }
84
85 constexpr bool isValid() const { return Reg != NoRegister; }
86
87 /// Comparisons between register objects
88 constexpr bool operator==(const MCRegister &Other) const {
89 return Reg == Other.Reg;
90 }
91 constexpr bool operator!=(const MCRegister &Other) const {
92 return Reg != Other.Reg;
93 }
94
95 /// Comparisons against register constants. E.g.
96 /// * R == AArch64::WZR
97 /// * R == 0
98 constexpr bool operator==(unsigned Other) const { return Reg == Other; }
99 constexpr bool operator!=(unsigned Other) const { return Reg != Other; }
100 constexpr bool operator==(int Other) const { return Reg == unsigned(Other); }
101 constexpr bool operator!=(int Other) const { return Reg != unsigned(Other); }
102 // MSVC requires that we explicitly declare these two as well.
103 constexpr bool operator==(MCPhysReg Other) const {
104 return Reg == unsigned(Other);
105 }
106 constexpr bool operator!=(MCPhysReg Other) const {
107 return Reg != unsigned(Other);
108 }
109};
110
111// Provide DenseMapInfo for MCRegister
112template <> struct DenseMapInfo<MCRegister> {
113 static inline MCRegister getEmptyKey() {
115 }
116 static inline MCRegister getTombstoneKey() {
118 }
119 static unsigned getHashValue(const MCRegister &Val) {
121 }
122 static bool isEqual(const MCRegister &LHS, const MCRegister &RHS) {
123 return LHS == RHS;
124 }
125};
126
128 return hash_value(Reg.id());
129}
130} // namespace llvm
131
132#endif // LLVM_MC_MCREGISTER_H
This file defines DenseMapInfo traits for DenseMap.
unsigned Reg
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
static constexpr bool isStackSlot(unsigned Reg)
This is the portion of the positive number space that is not a physical register.
Definition: MCRegister.h:61
constexpr bool isValid() const
Definition: MCRegister.h:85
static constexpr unsigned FirstPhysicalReg
Definition: MCRegister.h:53
constexpr bool operator==(const MCRegister &Other) const
Comparisons between register objects.
Definition: MCRegister.h:88
constexpr bool operator!=(MCPhysReg Other) const
Definition: MCRegister.h:106
static constexpr unsigned NoRegister
Definition: MCRegister.h:52
constexpr bool operator!=(int Other) const
Definition: MCRegister.h:101
static constexpr bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
Definition: MCRegister.h:67
constexpr MCRegister(unsigned Val=0)
Definition: MCRegister.h:38
static MCRegister from(unsigned Val)
Check the provided unsigned value is a valid MCRegister.
Definition: MCRegister.h:78
constexpr bool operator==(unsigned Other) const
Comparisons against register constants.
Definition: MCRegister.h:98
static constexpr unsigned FirstStackSlot
Definition: MCRegister.h:54
constexpr bool operator==(int Other) const
Definition: MCRegister.h:100
constexpr bool operator!=(const MCRegister &Other) const
Definition: MCRegister.h:91
constexpr bool isPhysical() const
Return true if the specified register number is in the physical register namespace.
Definition: MCRegister.h:73
friend hash_code hash_value(const MCRegister &)
Definition: MCRegister.h:127
constexpr bool operator==(MCPhysReg Other) const
Definition: MCRegister.h:103
static constexpr unsigned VirtualRegFlag
Definition: MCRegister.h:55
constexpr bool operator!=(unsigned Other) const
Definition: MCRegister.h:99
constexpr unsigned id() const
Definition: MCRegister.h:83
An opaque object representing a hash code.
Definition: Hashing.h:75
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
hash_code hash_value(const FixedPointSemantics &Val)
Definition: APFixedPoint.h:136
@ Other
Any other memory.
static bool isEqual(const MCRegister &LHS, const MCRegister &RHS)
Definition: MCRegister.h:122
static MCRegister getTombstoneKey()
Definition: MCRegister.h:116
static unsigned getHashValue(const MCRegister &Val)
Definition: MCRegister.h:119
static MCRegister getEmptyKey()
Definition: MCRegister.h:113
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: DenseMapInfo.h:52