LLVM 19.0.0git
RISCVRedundantCopyElimination.cpp
Go to the documentation of this file.
1//=- RISCVRedundantCopyElimination.cpp - Remove useless copy for RISC-V -----=//
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// This pass removes unnecessary zero copies in BBs that are targets of
10// beqz/bnez instructions. For instance, the copy instruction in the code below
11// can be removed because the beqz jumps to BB#2 when a0 is zero.
12// BB#1:
13// beqz %a0, <BB#2>
14// BB#2:
15// %a0 = COPY %x0
16// This pass should be run after register allocation.
17//
18// This pass is based on the earliest versions of
19// AArch64RedundantCopyElimination.
20//
21// FIXME: Support compares with constants other than zero? This is harder to
22// do on RISC-V since branches can't have immediates.
23//
24//===----------------------------------------------------------------------===//
25
26#include "RISCV.h"
27#include "RISCVInstrInfo.h"
28#include "llvm/ADT/Statistic.h"
31#include "llvm/Support/Debug.h"
32
33using namespace llvm;
34
35#define DEBUG_TYPE "riscv-copyelim"
36
37STATISTIC(NumCopiesRemoved, "Number of copies removed.");
38
39namespace {
40class RISCVRedundantCopyElimination : public MachineFunctionPass {
43 const TargetInstrInfo *TII;
44
45public:
46 static char ID;
47 RISCVRedundantCopyElimination() : MachineFunctionPass(ID) {
50 }
51
52 bool runOnMachineFunction(MachineFunction &MF) override;
55 MachineFunctionProperties::Property::NoVRegs);
56 }
57
58 StringRef getPassName() const override {
59 return "RISC-V Redundant Copy Elimination";
60 }
61
62private:
64};
65
66} // end anonymous namespace
67
68char RISCVRedundantCopyElimination::ID = 0;
69
70INITIALIZE_PASS(RISCVRedundantCopyElimination, "riscv-copyelim",
71 "RISC-V Redundant Copy Elimination", false, false)
72
73static bool
74guaranteesZeroRegInBlock(MachineBasicBlock &MBB,
77 assert(Cond.size() == 3 && "Unexpected number of operands");
78 assert(TBB != nullptr && "Expected branch target basic block");
79 auto CC = static_cast<RISCVCC::CondCode>(Cond[0].getImm());
80 if (CC == RISCVCC::COND_EQ && Cond[2].getReg() == RISCV::X0 && TBB == &MBB)
81 return true;
82 if (CC == RISCVCC::COND_NE && Cond[2].getReg() == RISCV::X0 && TBB != &MBB)
83 return true;
84 return false;
85}
86
87bool RISCVRedundantCopyElimination::optimizeBlock(MachineBasicBlock &MBB) {
88 // Check if the current basic block has a single predecessor.
89 if (MBB.pred_size() != 1)
90 return false;
91
92 // Check if the predecessor has two successors, implying the block ends in a
93 // conditional branch.
94 MachineBasicBlock *PredMBB = *MBB.pred_begin();
95 if (PredMBB->succ_size() != 2)
96 return false;
97
98 MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
100 if (TII->analyzeBranch(*PredMBB, TBB, FBB, Cond, /*AllowModify*/ false) ||
101 Cond.empty())
102 return false;
103
104 // Is this a branch with X0?
105 if (!guaranteesZeroRegInBlock(MBB, Cond, TBB))
106 return false;
107
108 Register TargetReg = Cond[1].getReg();
109 if (!TargetReg)
110 return false;
111
112 bool Changed = false;
114 // Remove redundant Copy instructions unless TargetReg is modified.
115 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E;) {
116 MachineInstr *MI = &*I;
117 ++I;
118 if (MI->isCopy() && MI->getOperand(0).isReg() &&
119 MI->getOperand(1).isReg()) {
120 Register DefReg = MI->getOperand(0).getReg();
121 Register SrcReg = MI->getOperand(1).getReg();
122
123 if (SrcReg == RISCV::X0 && !MRI->isReserved(DefReg) &&
124 TargetReg == DefReg) {
125 LLVM_DEBUG(dbgs() << "Remove redundant Copy : ");
126 LLVM_DEBUG(MI->print(dbgs()));
127
128 MI->eraseFromParent();
129 Changed = true;
130 LastChange = I;
131 ++NumCopiesRemoved;
132 continue;
133 }
134 }
135
136 if (MI->modifiesRegister(TargetReg, TRI))
137 break;
138 }
139
140 if (!Changed)
141 return false;
142
144 assert((CondBr->getOpcode() == RISCV::BEQ ||
145 CondBr->getOpcode() == RISCV::BNE) &&
146 "Unexpected opcode");
147 assert(CondBr->getOperand(0).getReg() == TargetReg && "Unexpected register");
148
149 // Otherwise, we have to fixup the use-def chain, starting with the
150 // BEQ/BNE. Conservatively mark as much as we can live.
151 CondBr->clearRegisterKills(TargetReg, TRI);
152
153 // Add newly used reg to the block's live-in list if it isn't there already.
154 if (!MBB.isLiveIn(TargetReg))
155 MBB.addLiveIn(TargetReg);
156
157 // Clear any kills of TargetReg between CondBr and the last removed COPY.
158 for (MachineInstr &MMI : make_range(MBB.begin(), LastChange))
159 MMI.clearRegisterKills(TargetReg, TRI);
160
161 return true;
162}
163
164bool RISCVRedundantCopyElimination::runOnMachineFunction(MachineFunction &MF) {
165 if (skipFunction(MF.getFunction()))
166 return false;
167
170 MRI = &MF.getRegInfo();
171
172 bool Changed = false;
173 for (MachineBasicBlock &MBB : MF)
174 Changed |= optimizeBlock(MBB);
175
176 return Changed;
177}
178
180 return new RISCVRedundantCopyElimination();
181}
unsigned const MachineRegisterInfo * MRI
aarch64 promote const
MachineBasicBlock & MBB
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DEBUG(X)
Definition: Debug.h:101
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned const TargetRegisterInfo * TRI
static unsigned getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
const SmallVectorImpl< MachineOperand > & Cond
assert(TBB !=nullptr &&"Expected branch target basic block")
static bool optimizeBlock(BasicBlock &BB, bool &ModifiedDT, const TargetTransformInfo &TTI, const DataLayout &DL, DomTreeUpdater *DTU)
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
Analyze the branching code at the end of MBB, returning true if it cannot be understood (e....
unsigned pred_size() const
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
unsigned succ_size() const
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
virtual MachineFunctionProperties getRequiredProperties() const
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void print(raw_ostream &OS, const Module *M) const
print - Print out the internal state of the pass.
Definition: Pass.cpp:130
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetInstrInfo * getInstrInfo() const
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void initializeRISCVRedundantCopyEliminationPass(PassRegistry &)
FunctionPass * createRISCVRedundantCopyEliminationPass()
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163