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
15 #include "llvm/CodeGen/MachineBasicBlock.h"
16 #include "llvm/CodeGen/MachineFrameInfo.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/CodeGen/MachineInstrBundle.h"
19 #include "llvm/CodeGen/MachineOperand.h"
20 #include "llvm/CodeGen/MachineRegisterInfo.h"
21 #include "llvm/CodeGen/TargetRegisterInfo.h"
22 #include "llvm/MC/MCRegisterInfo.h"
23
24 using namespace llvm;
25
removeRegsNotPreserved(const uint32_t * RegMask)26 void LiveRegUnits::removeRegsNotPreserved(const uint32_t *RegMask) {
27 for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
28 for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
29 if (MachineOperand::clobbersPhysReg(RegMask, *RootReg))
30 Units.reset(U);
31 }
32 }
33 }
34
addRegsInMask(const uint32_t * RegMask)35 void LiveRegUnits::addRegsInMask(const uint32_t *RegMask) {
36 for (unsigned U = 0, E = TRI->getNumRegUnits(); U != E; ++U) {
37 for (MCRegUnitRootIterator RootReg(U, TRI); RootReg.isValid(); ++RootReg) {
38 if (MachineOperand::clobbersPhysReg(RegMask, *RootReg))
39 Units.set(U);
40 }
41 }
42 }
43
stepBackward(const MachineInstr & MI)44 void LiveRegUnits::stepBackward(const MachineInstr &MI) {
45 // Remove defined registers and regmask kills from the set.
46 for (const MachineOperand &MOP : phys_regs_and_masks(MI)) {
47 if (MOP.isRegMask()) {
48 removeRegsNotPreserved(MOP.getRegMask());
49 continue;
50 }
51
52 if (MOP.isDef())
53 removeReg(MOP.getReg());
54 }
55
56 // Add uses to the set.
57 for (const MachineOperand &MOP : phys_regs_and_masks(MI)) {
58 if (!MOP.isReg() || !MOP.readsReg())
59 continue;
60 addReg(MOP.getReg());
61 }
62 }
63
accumulate(const MachineInstr & MI)64 void LiveRegUnits::accumulate(const MachineInstr &MI) {
65 // Add defs, uses and regmask clobbers to the set.
66 for (const MachineOperand &MOP : phys_regs_and_masks(MI)) {
67 if (MOP.isRegMask()) {
68 addRegsInMask(MOP.getRegMask());
69 continue;
70 }
71 if (!MOP.isDef() && !MOP.readsReg())
72 continue;
73 addReg(MOP.getReg());
74 }
75 }
76
77 /// Add live-in registers of basic block \p MBB to \p LiveUnits.
addBlockLiveIns(LiveRegUnits & LiveUnits,const MachineBasicBlock & MBB)78 static void addBlockLiveIns(LiveRegUnits &LiveUnits,
79 const MachineBasicBlock &MBB) {
80 for (const auto &LI : MBB.liveins())
81 LiveUnits.addRegMasked(LI.PhysReg, LI.LaneMask);
82 }
83
84 /// Adds all callee saved registers to \p LiveUnits.
addCalleeSavedRegs(LiveRegUnits & LiveUnits,const MachineFunction & MF)85 static void addCalleeSavedRegs(LiveRegUnits &LiveUnits,
86 const MachineFunction &MF) {
87 const MachineRegisterInfo &MRI = MF.getRegInfo();
88 for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR; ++CSR)
89 LiveUnits.addReg(*CSR);
90 }
91
addPristines(const MachineFunction & MF)92 void LiveRegUnits::addPristines(const MachineFunction &MF) {
93 const MachineFrameInfo &MFI = MF.getFrameInfo();
94 if (!MFI.isCalleeSavedInfoValid())
95 return;
96 /// This function will usually be called on an empty object, handle this
97 /// as a special case.
98 if (empty()) {
99 /// Add all callee saved regs, then remove the ones that are saved and
100 /// restored.
101 addCalleeSavedRegs(*this, MF);
102 /// Remove the ones that are not saved/restored; they are pristine.
103 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
104 removeReg(Info.getReg());
105 return;
106 }
107 /// If a callee-saved register that is not pristine is already present
108 /// in the set, we should make sure that it stays in it. Precompute the
109 /// set of pristine registers in a separate object.
110 /// Add all callee saved regs, then remove the ones that are saved+restored.
111 LiveRegUnits Pristine(*TRI);
112 addCalleeSavedRegs(Pristine, MF);
113 /// Remove the ones that are not saved/restored; they are pristine.
114 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
115 Pristine.removeReg(Info.getReg());
116 addUnits(Pristine.getBitVector());
117 }
118
addLiveOuts(const MachineBasicBlock & MBB)119 void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
120 const MachineFunction &MF = *MBB.getParent();
121
122 addPristines(MF);
123
124 // To get the live-outs we simply merge the live-ins of all successors.
125 for (const MachineBasicBlock *Succ : MBB.successors())
126 addBlockLiveIns(*this, *Succ);
127
128 // For the return block: Add all callee saved registers.
129 if (MBB.isReturnBlock()) {
130 const MachineFrameInfo &MFI = MF.getFrameInfo();
131 if (MFI.isCalleeSavedInfoValid())
132 addCalleeSavedRegs(*this, MF);
133 }
134 }
135
addLiveIns(const MachineBasicBlock & MBB)136 void LiveRegUnits::addLiveIns(const MachineBasicBlock &MBB) {
137 const MachineFunction &MF = *MBB.getParent();
138 addPristines(MF);
139 addBlockLiveIns(*this, MBB);
140 }
141