1//==-- AArch64DeadRegisterDefinitions.cpp - Replace dead defs w/ zero reg --==//
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/// \file When allowed by the instruction, replace a dead definition of a GPR
9/// with the zero register. This makes the code a bit friendlier towards the
10/// hardware's register renamer.
11//===----------------------------------------------------------------------===//
12
13#include "AArch64.h"
14#include "AArch64Subtarget.h"
15#include "llvm/ADT/Statistic.h"
16#include "llvm/CodeGen/MachineFunction.h"
17#include "llvm/CodeGen/MachineFunctionPass.h"
18#include "llvm/CodeGen/MachineInstr.h"
19#include "llvm/CodeGen/MachineRegisterInfo.h"
20#include "llvm/CodeGen/TargetInstrInfo.h"
21#include "llvm/CodeGen/TargetSubtargetInfo.h"
22#include "llvm/Support/Debug.h"
23#include "llvm/Support/raw_ostream.h"
24using namespace llvm;
25
26#define DEBUG_TYPE "aarch64-dead-defs"
27
28STATISTIC(NumDeadDefsReplaced, "Number of dead definitions replaced");
29
30#define AARCH64_DEAD_REG_DEF_NAME "AArch64 Dead register definitions"
31
32namespace {
33class AArch64DeadRegisterDefinitionsImpl {
34public:
35 bool run(MachineFunction &MF);
36
37private:
38 const MachineRegisterInfo *MRI;
39 const TargetInstrInfo *TII;
40 bool Changed;
41 void processMachineBasicBlock(MachineBasicBlock &MBB);
42};
43
44class AArch64DeadRegisterDefinitionsLegacy : public MachineFunctionPass {
45public:
46 static char ID; // Pass identification, replacement for typeid.
47 AArch64DeadRegisterDefinitionsLegacy() : MachineFunctionPass(ID) {}
48
49 bool runOnMachineFunction(MachineFunction &F) override;
50
51 StringRef getPassName() const override { return AARCH64_DEAD_REG_DEF_NAME; }
52
53 void getAnalysisUsage(AnalysisUsage &AU) const override {
54 AU.setPreservesCFG();
55 MachineFunctionPass::getAnalysisUsage(AU);
56 }
57};
58char AArch64DeadRegisterDefinitionsLegacy::ID = 0;
59} // end anonymous namespace
60
61INITIALIZE_PASS(AArch64DeadRegisterDefinitionsLegacy, "aarch64-dead-defs",
62 AARCH64_DEAD_REG_DEF_NAME, false, false)
63
64static bool usesFrameIndex(const MachineInstr &MI) {
65 for (const MachineOperand &MO : MI.uses())
66 if (MO.isFI())
67 return true;
68 return false;
69}
70
71// Instructions that lose their 'read' operation for a subsequent fence acquire
72// (DMB LD) once the zero register is used.
73//
74// WARNING: The acquire variants of the instructions are also affected, but they
75// are split out into `atomicBarrierDroppedOnZero()` to support annotations on
76// assembly.
77static bool atomicReadDroppedOnZero(unsigned Opcode) {
78 switch (Opcode) {
79 case AArch64::LDADDB: case AArch64::LDADDH:
80 case AArch64::LDADDW: case AArch64::LDADDX:
81 case AArch64::LDADDLB: case AArch64::LDADDLH:
82 case AArch64::LDADDLW: case AArch64::LDADDLX:
83 case AArch64::LDCLRB: case AArch64::LDCLRH:
84 case AArch64::LDCLRW: case AArch64::LDCLRX:
85 case AArch64::LDCLRLB: case AArch64::LDCLRLH:
86 case AArch64::LDCLRLW: case AArch64::LDCLRLX:
87 case AArch64::LDEORB: case AArch64::LDEORH:
88 case AArch64::LDEORW: case AArch64::LDEORX:
89 case AArch64::LDEORLB: case AArch64::LDEORLH:
90 case AArch64::LDEORLW: case AArch64::LDEORLX:
91 case AArch64::LDSETB: case AArch64::LDSETH:
92 case AArch64::LDSETW: case AArch64::LDSETX:
93 case AArch64::LDSETLB: case AArch64::LDSETLH:
94 case AArch64::LDSETLW: case AArch64::LDSETLX:
95 case AArch64::LDSMAXB: case AArch64::LDSMAXH:
96 case AArch64::LDSMAXW: case AArch64::LDSMAXX:
97 case AArch64::LDSMAXLB: case AArch64::LDSMAXLH:
98 case AArch64::LDSMAXLW: case AArch64::LDSMAXLX:
99 case AArch64::LDSMINB: case AArch64::LDSMINH:
100 case AArch64::LDSMINW: case AArch64::LDSMINX:
101 case AArch64::LDSMINLB: case AArch64::LDSMINLH:
102 case AArch64::LDSMINLW: case AArch64::LDSMINLX:
103 case AArch64::LDUMAXB: case AArch64::LDUMAXH:
104 case AArch64::LDUMAXW: case AArch64::LDUMAXX:
105 case AArch64::LDUMAXLB: case AArch64::LDUMAXLH:
106 case AArch64::LDUMAXLW: case AArch64::LDUMAXLX:
107 case AArch64::LDUMINB: case AArch64::LDUMINH:
108 case AArch64::LDUMINW: case AArch64::LDUMINX:
109 case AArch64::LDUMINLB: case AArch64::LDUMINLH:
110 case AArch64::LDUMINLW: case AArch64::LDUMINLX:
111 case AArch64::SWPB: case AArch64::SWPH:
112 case AArch64::SWPW: case AArch64::SWPX:
113 case AArch64::SWPLB: case AArch64::SWPLH:
114 case AArch64::SWPLW: case AArch64::SWPLX:
115 return true;
116 }
117 return false;
118}
119
120void AArch64DeadRegisterDefinitionsImpl::processMachineBasicBlock(
121 MachineBasicBlock &MBB) {
122 for (MachineInstr &MI : MBB) {
123 if (usesFrameIndex(MI)) {
124 // We need to skip this instruction because while it appears to have a
125 // dead def it uses a frame index which might expand into a multi
126 // instruction sequence during EPI.
127 LLVM_DEBUG(dbgs() << " Ignoring, operand is frame index\n");
128 continue;
129 }
130 if (MI.definesRegister(Reg: AArch64::XZR, /*TRI=*/nullptr) ||
131 MI.definesRegister(Reg: AArch64::WZR, /*TRI=*/nullptr)) {
132 // It is not allowed to write to the same register (not even the zero
133 // register) twice in a single instruction.
134 LLVM_DEBUG(
135 dbgs()
136 << " Ignoring, XZR or WZR already used by the instruction\n");
137 continue;
138 }
139
140 if (atomicBarrierDroppedOnZero(Opcode: MI.getOpcode()) || atomicReadDroppedOnZero(Opcode: MI.getOpcode())) {
141 LLVM_DEBUG(dbgs() << " Ignoring, semantics change with xzr/wzr.\n");
142 continue;
143 }
144
145 const MCInstrDesc &Desc = MI.getDesc();
146 for (int I = 0, E = Desc.getNumDefs(); I != E; ++I) {
147 MachineOperand &MO = MI.getOperand(i: I);
148 if (!MO.isReg() || !MO.isDef())
149 continue;
150 // We should not have any relevant physreg defs that are replacable by
151 // zero before register allocation. So we just check for dead vreg defs.
152 Register Reg = MO.getReg();
153 if (!Reg.isVirtual() || (!MO.isDead() && !MRI->use_nodbg_empty(RegNo: Reg)))
154 continue;
155 assert(!MO.isImplicit() && "Unexpected implicit def!");
156 LLVM_DEBUG(dbgs() << " Dead def operand #" << I << " in:\n ";
157 MI.print(dbgs()));
158 // Be careful not to change the register if it's a tied operand.
159 if (MI.isRegTiedToUseOperand(DefOpIdx: I)) {
160 LLVM_DEBUG(dbgs() << " Ignoring, def is tied operand.\n");
161 continue;
162 }
163 const TargetRegisterClass *RC = TII->getRegClass(MCID: Desc, OpNum: I);
164 unsigned NewReg;
165 if (RC == nullptr) {
166 LLVM_DEBUG(dbgs() << " Ignoring, register is not a GPR.\n");
167 continue;
168 } else if (RC->contains(Reg: AArch64::WZR))
169 NewReg = AArch64::WZR;
170 else if (RC->contains(Reg: AArch64::XZR))
171 NewReg = AArch64::XZR;
172 else {
173 LLVM_DEBUG(dbgs() << " Ignoring, register is not a GPR.\n");
174 continue;
175 }
176 LLVM_DEBUG(dbgs() << " Replacing with zero register. New:\n ");
177 MO.setReg(NewReg);
178 MO.setIsDead();
179 LLVM_DEBUG(MI.print(dbgs()));
180 ++NumDeadDefsReplaced;
181 Changed = true;
182 // Only replace one dead register, see check for zero register above.
183 break;
184 }
185 }
186}
187
188// Scan the function for instructions that have a dead definition of a
189// register. Replace that register with the zero register when possible.
190bool AArch64DeadRegisterDefinitionsImpl::run(MachineFunction &MF) {
191 TII = MF.getSubtarget().getInstrInfo();
192 MRI = &MF.getRegInfo();
193 LLVM_DEBUG(dbgs() << "***** AArch64DeadRegisterDefinitions *****\n");
194 Changed = false;
195 for (auto &MBB : MF)
196 processMachineBasicBlock(MBB);
197 return Changed;
198}
199
200bool AArch64DeadRegisterDefinitionsLegacy::runOnMachineFunction(
201 MachineFunction &MF) {
202 if (skipFunction(F: MF.getFunction()))
203 return false;
204 return AArch64DeadRegisterDefinitionsImpl().run(MF);
205}
206
207PreservedAnalyses
208AArch64DeadRegisterDefinitionsPass::run(MachineFunction &MF,
209 MachineFunctionAnalysisManager &MFAM) {
210 const bool Changed = AArch64DeadRegisterDefinitionsImpl().run(MF);
211 if (!Changed)
212 return PreservedAnalyses::all();
213 PreservedAnalyses PA = getMachineFunctionPassPreservedAnalyses();
214 PA.preserveSet<CFGAnalyses>();
215 return PA;
216}
217
218FunctionPass *llvm::createAArch64DeadRegisterDefinitions() {
219 return new AArch64DeadRegisterDefinitionsLegacy();
220}
221