LLVM  16.0.0git
LiveRegUnits.cpp
Go to the documentation of this file.
1 //===- LiveRegUnits.cpp - Register Unit Set -------------------------------===//
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 /// \file This file imlements the LiveRegUnits set.
10 //
11 //===----------------------------------------------------------------------===//
12 
19 
20 using namespace llvm;
21 
23  for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
24  for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
25  if (MachineOperand::clobbersPhysReg(RegMask, *RootReg)) {
26  Units.reset(U);
27  break;
28  }
29  }
30  }
31 }
32 
33 void LiveRegUnits::addRegsInMask(const uint32_t *RegMask) {
34  for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
35  for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
36  if (MachineOperand::clobbersPhysReg(RegMask, *RootReg)) {
37  Units.set(U);
38  break;
39  }
40  }
41  }
42 }
43 
45  // Remove defined registers and regmask kills from the set.
46  for (const MachineOperand &MOP : MI.operands()) {
47  if (MOP.isReg()) {
48  if (MOP.isDef() && MOP.getReg().isPhysical())
49  removeReg(MOP.getReg());
50  continue;
51  }
52 
53  if (MOP.isRegMask()) {
54  removeRegsNotPreserved(MOP.getRegMask());
55  continue;
56  }
57  }
58 
59  // Add uses to the set.
60  for (const MachineOperand &MOP : MI.operands()) {
61  if (!MOP.isReg() || !MOP.readsReg())
62  continue;
63 
64  if (MOP.getReg().isPhysical())
65  addReg(MOP.getReg());
66  }
67 }
68 
70  // Add defs, uses and regmask clobbers to the set.
71  for (const MachineOperand &MOP : MI.operands()) {
72  if (MOP.isReg()) {
73  if (!MOP.getReg().isPhysical())
74  continue;
75  if (MOP.isDef() || MOP.readsReg())
76  addReg(MOP.getReg());
77  continue;
78  }
79 
80  if (MOP.isRegMask()) {
81  addRegsInMask(MOP.getRegMask());
82  continue;
83  }
84  }
85 }
86 
87 /// Add live-in registers of basic block \p MBB to \p LiveUnits.
88 static void addBlockLiveIns(LiveRegUnits &LiveUnits,
89  const MachineBasicBlock &MBB) {
90  for (const auto &LI : MBB.liveins())
91  LiveUnits.addRegMasked(LI.PhysReg, LI.LaneMask);
92 }
93 
94 /// Adds all callee saved registers to \p LiveUnits.
95 static void addCalleeSavedRegs(LiveRegUnits &LiveUnits,
96  const MachineFunction &MF) {
97  const MachineRegisterInfo &MRI = MF.getRegInfo();
98  const MachineFrameInfo &MFI = MF.getFrameInfo();
99  for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR) {
100  const unsigned N = *CSR;
101 
102  const auto &CSI = MFI.getCalleeSavedInfo();
103  auto Info =
104  llvm::find_if(CSI, [N](auto Info) { return Info.getReg() == N; });
105  // If we have no info for this callee-saved register, assume it is liveout
106  if (Info == CSI.end() || Info->isRestored())
107  LiveUnits.addReg(N);
108  }
109 }
110 
111 void LiveRegUnits::addPristines(const MachineFunction &MF) {
112  const MachineFrameInfo &MFI = MF.getFrameInfo();
113  if (!MFI.isCalleeSavedInfoValid())
114  return;
115  /// This function will usually be called on an empty object, handle this
116  /// as a special case.
117  if (empty()) {
118  /// Add all callee saved regs, then remove the ones that are saved and
119  /// restored.
120  addCalleeSavedRegs(*this, MF);
121  /// Remove the ones that are not saved/restored; they are pristine.
122  for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
123  removeReg(Info.getReg());
124  return;
125  }
126  /// If a callee-saved register that is not pristine is already present
127  /// in the set, we should make sure that it stays in it. Precompute the
128  /// set of pristine registers in a separate object.
129  /// Add all callee saved regs, then remove the ones that are saved+restored.
130  LiveRegUnits Pristine(*TRI);
131  addCalleeSavedRegs(Pristine, MF);
132  /// Remove the ones that are not saved/restored; they are pristine.
133  for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
134  Pristine.removeReg(Info.getReg());
135  addUnits(Pristine.getBitVector());
136 }
137 
139  const MachineFunction &MF = *MBB.getParent();
140 
141  addPristines(MF);
142 
143  // To get the live-outs we simply merge the live-ins of all successors.
144  for (const MachineBasicBlock *Succ : MBB.successors())
145  addBlockLiveIns(*this, *Succ);
146 
147  // For the return block: Add all callee saved registers.
148  if (MBB.isReturnBlock()) {
149  const MachineFrameInfo &MFI = MF.getFrameInfo();
150  if (MFI.isCalleeSavedInfoValid())
151  addCalleeSavedRegs(*this, MF);
152  }
153 }
154 
156  const MachineFunction &MF = *MBB.getParent();
157  addPristines(MF);
158  addBlockLiveIns(*this, MBB);
159 }
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:108
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:50
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:344
MachineBasicBlock.h
llvm::MachineBasicBlock::isReturnBlock
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
Definition: MachineBasicBlock.h:864
llvm::LiveRegUnits::addReg
void addReg(MCPhysReg Reg)
Adds register units covered by physical register Reg.
Definition: LiveRegUnits.h:86
llvm::MachineBasicBlock::liveins
iterator_range< livein_iterator > liveins() const
Definition: MachineBasicBlock.h:449
llvm::LiveRegUnits::addUnits
void addUnits(const BitVector &RegUnits)
Adds all register units marked in the bitvector RegUnits.
Definition: LiveRegUnits.h:144
llvm::LiveRegUnits::addLiveIns
void addLiveIns(const MachineBasicBlock &MBB)
Adds registers living into block MBB.
Definition: LiveRegUnits.cpp:155
llvm::LiveRegUnits::addRegMasked
void addRegMasked(MCPhysReg Reg, LaneBitmask Mask)
Adds register units covered by physical register Reg that are part of the lanemask Mask.
Definition: LiveRegUnits.h:93
llvm::MCRegisterInfo::getNumRegUnits
unsigned getNumRegUnits() const
Return the number of (native) register units in the target.
Definition: MCRegisterInfo.h:505
llvm::LiveRegUnits::empty
bool empty() const
Returns true if the set is empty.
Definition: LiveRegUnits.h:83
MachineRegisterInfo.h
addBlockLiveIns
static void addBlockLiveIns(LiveRegUnits &LiveUnits, const MachineBasicBlock &MBB)
Add live-in registers of basic block MBB to LiveUnits.
Definition: LiveRegUnits.cpp:88
llvm::LiveRegUnits::addLiveOuts
void addLiveOuts(const MachineBasicBlock &MBB)
Adds registers living out of block MBB.
Definition: LiveRegUnits.cpp:138
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:667
llvm::LiveRegUnits::accumulate
void accumulate(const MachineInstr &MI)
Adds all register units used, defined or clobbered in MI.
Definition: LiveRegUnits.cpp:69
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::LiveRegUnits
A set of register units used to track register liveness.
Definition: LiveRegUnits.h:30
llvm::LiveRegUnits::removeReg
void removeReg(MCPhysReg Reg)
Removes all register units covered by physical register Reg.
Definition: LiveRegUnits.h:102
llvm::MachineFrameInfo::isCalleeSavedInfoValid
bool isCalleeSavedInfoValid() const
Has the callee saved info been calculated yet?
Definition: MachineFrameInfo.h:800
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::MCRegUnitRootIterator::isValid
bool isValid() const
Check if the iterator is at the end of the list.
Definition: MCRegisterInfo.h:773
llvm::LiveRegUnits::stepBackward
void stepBackward(const MachineInstr &MI)
Updates liveness when stepping backwards over the instruction MI.
Definition: LiveRegUnits.cpp:44
llvm::MachineOperand::clobbersPhysReg
static bool clobbersPhysReg(const uint32_t *RegMask, MCRegister PhysReg)
clobbersPhysReg - Returns true if this RegMask clobbers PhysReg.
Definition: MachineOperand.h:626
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::MachineRegisterInfo::getCalleeSavedRegs
const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
Definition: MachineRegisterInfo.cpp:623
llvm::MCPhysReg
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:21
addCalleeSavedRegs
static void addCalleeSavedRegs(LiveRegUnits &LiveUnits, const MachineFunction &MF)
Adds all callee saved registers to LiveUnits.
Definition: LiveRegUnits.cpp:95
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:673
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:261
llvm::MachineFunction
Definition: MachineFunction.h:257
llvm::MachineFrameInfo::getCalleeSavedInfo
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
Definition: MachineFrameInfo.h:787
llvm::MachineBasicBlock::successors
iterator_range< succ_iterator > successors()
Definition: MachineBasicBlock.h:392
uint32_t
LiveRegUnits.h
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1736
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::CalleeSavedInfo
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
Definition: MachineFrameInfo.h:34
MachineFrameInfo.h
llvm::LiveRegUnits::removeRegsNotPreserved
void removeRegsNotPreserved(const uint32_t *RegMask)
Removes register units not preserved by the regmask RegMask.
Definition: LiveRegUnits.cpp:22
llvm::BitVector::reset
BitVector & reset()
Definition: BitVector.h:385
llvm::MCRegUnitRootIterator
MCRegUnitRootIterator enumerates the root registers of a register unit.
Definition: MCRegisterInfo.h:754
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:106
N
#define N
MachineOperand.h
llvm::LiveRegUnits::addRegsInMask
void addRegsInMask(const uint32_t *RegMask)
Adds register units not preserved by the regmask RegMask.
Definition: LiveRegUnits.cpp:33
MachineFunction.h