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
13#include "llvm/CodeGen/LiveRegUnits.h"
14#include "llvm/CodeGen/MachineBasicBlock.h"
15#include "llvm/CodeGen/MachineFrameInfo.h"
16#include "llvm/CodeGen/MachineFunction.h"
17#include "llvm/CodeGen/MachineOperand.h"
18#include "llvm/CodeGen/MachineRegisterInfo.h"
19
20using namespace llvm;
21
22void LiveRegUnits::removeRegsNotPreserved(const uint32_t *RegMask) {
23 for (MCRegUnit U : TRI->regunits()) {
24 for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
25 if (MachineOperand::clobbersPhysReg(RegMask, PhysReg: *RootReg)) {
26 Units.reset(Idx: static_cast<unsigned>(U));
27 break;
28 }
29 }
30 }
31}
32
33void LiveRegUnits::addRegsInMask(const uint32_t *RegMask) {
34 for (MCRegUnit U : TRI->regunits()) {
35 for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
36 if (MachineOperand::clobbersPhysReg(RegMask, PhysReg: *RootReg)) {
37 Units.set(static_cast<unsigned>(U));
38 break;
39 }
40 }
41 }
42}
43
44void LiveRegUnits::stepBackward(const MachineInstr &MI) {
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(Reg: MOP.getReg());
50 continue;
51 }
52
53 if (MOP.isRegMask()) {
54 removeRegsNotPreserved(RegMask: 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(Reg: MOP.getReg());
66 }
67}
68
69void LiveRegUnits::accumulate(const MachineInstr &MI) {
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(Reg: MOP.getReg());
77 continue;
78 }
79
80 if (MOP.isRegMask()) {
81 addRegsInMask(RegMask: MOP.getRegMask());
82 continue;
83 }
84 }
85}
86
87/// Add live-in registers of basic block \p MBB to \p LiveUnits.
88static void addBlockLiveIns(LiveRegUnits &LiveUnits,
89 const MachineBasicBlock &MBB) {
90 for (const auto &LI : MBB.liveins())
91 LiveUnits.addRegMasked(Reg: LI.PhysReg, Mask: LI.LaneMask);
92}
93
94/// Add live-out registers of basic block \p MBB to \p LiveUnits.
95static void addBlockLiveOuts(LiveRegUnits &LiveUnits,
96 const MachineBasicBlock &MBB) {
97 for (const auto &LO : MBB.liveouts())
98 LiveUnits.addRegMasked(Reg: LO.PhysReg, Mask: LO.LaneMask);
99}
100
101/// Adds all callee saved registers to \p LiveUnits.
102static void addCalleeSavedRegs(LiveRegUnits &LiveUnits,
103 const MachineFunction &MF) {
104 const MachineRegisterInfo &MRI = MF.getRegInfo();
105 const MachineFrameInfo &MFI = MF.getFrameInfo();
106 for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR) {
107 const unsigned N = *CSR;
108
109 const auto &CSI = MFI.getCalleeSavedInfo();
110 auto Info =
111 llvm::find_if(Range: CSI, P: [N](auto Info) { return Info.getReg() == N; });
112 // If we have no info for this callee-saved register, assume it is liveout
113 if (Info == CSI.end() || Info->isRestored())
114 LiveUnits.addReg(Reg: N);
115 }
116}
117
118void LiveRegUnits::addPristines(const MachineFunction &MF) {
119 const MachineFrameInfo &MFI = MF.getFrameInfo();
120 if (!MFI.isCalleeSavedInfoValid())
121 return;
122 /// This function will usually be called on an empty object, handle this
123 /// as a special case.
124 if (empty()) {
125 /// Add all callee saved regs, then remove the ones that are saved and
126 /// restored.
127 addCalleeSavedRegs(LiveUnits&: *this, MF);
128 /// Remove the ones that are not saved/restored; they are pristine.
129 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
130 removeReg(Reg: Info.getReg());
131 return;
132 }
133 /// If a callee-saved register that is not pristine is already present
134 /// in the set, we should make sure that it stays in it. Precompute the
135 /// set of pristine registers in a separate object.
136 /// Add all callee saved regs, then remove the ones that are saved+restored.
137 LiveRegUnits Pristine(*TRI);
138 addCalleeSavedRegs(LiveUnits&: Pristine, MF);
139 /// Remove the ones that are not saved/restored; they are pristine.
140 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
141 Pristine.removeReg(Reg: Info.getReg());
142 addUnits(RegUnits: Pristine.getBitVector());
143}
144
145void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
146 const MachineFunction &MF = *MBB.getParent();
147 addPristines(MF);
148 addBlockLiveOuts(LiveUnits&: *this, MBB);
149
150 // For the return block: Add all callee saved registers.
151 if (MBB.isReturnBlock()) {
152 const MachineFrameInfo &MFI = MF.getFrameInfo();
153 if (MFI.isCalleeSavedInfoValid())
154 addCalleeSavedRegs(LiveUnits&: *this, MF);
155 }
156}
157
158void LiveRegUnits::addLiveIns(const MachineBasicBlock &MBB) {
159 const MachineFunction &MF = *MBB.getParent();
160 addPristines(MF);
161 addBlockLiveIns(LiveUnits&: *this, MBB);
162}
163