LLVM 18.0.0git
MipsOptimizePICCall.cpp
Go to the documentation of this file.
1//===- MipsOptimizePICCall.cpp - Optimize PIC Calls -----------------------===//
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 eliminates unnecessary instructions that set up $gp and replace
10// instructions that load target function addresses with copy instructions.
11//
12//===----------------------------------------------------------------------===//
13
15#include "Mips.h"
16#include "MipsRegisterInfo.h"
17#include "MipsSubtarget.h"
38#include <cassert>
39#include <utility>
40#include <vector>
41
42using namespace llvm;
43
44#define DEBUG_TYPE "optimize-mips-pic-call"
45
46static cl::opt<bool> LoadTargetFromGOT("mips-load-target-from-got",
47 cl::init(true),
48 cl::desc("Load target address from GOT"),
50
51static cl::opt<bool> EraseGPOpnd("mips-erase-gp-opnd",
52 cl::init(true), cl::desc("Erase GP Operand"),
54
55namespace {
56
58using CntRegP = std::pair<unsigned, unsigned>;
59using AllocatorTy = RecyclingAllocator<BumpPtrAllocator,
61using ScopedHTType = ScopedHashTable<ValueType, CntRegP,
62 DenseMapInfo<ValueType>, AllocatorTy>;
63
64class MBBInfo {
65public:
66 MBBInfo(MachineDomTreeNode *N);
67
68 const MachineDomTreeNode *getNode() const;
69 bool isVisited() const;
70 void preVisit(ScopedHTType &ScopedHT);
71 void postVisit();
72
73private:
75 ScopedHTType::ScopeTy *HTScope;
76};
77
78class OptimizePICCall : public MachineFunctionPass {
79public:
80 OptimizePICCall() : MachineFunctionPass(ID) {}
81
82 StringRef getPassName() const override { return "Mips OptimizePICCall"; }
83
85
86 void getAnalysisUsage(AnalysisUsage &AU) const override {
89 }
90
91private:
92 /// Visit MBB.
93 bool visitNode(MBBInfo &MBBI);
94
95 /// Test if MI jumps to a function via a register.
96 ///
97 /// Also, return the virtual register containing the target function's address
98 /// and the underlying object in Reg and Val respectively, if the function's
99 /// address can be resolved lazily.
100 bool isCallViaRegister(MachineInstr &MI, unsigned &Reg,
101 ValueType &Val) const;
102
103 /// Return the number of instructions that dominate the current
104 /// instruction and load the function address from object Entry.
105 unsigned getCount(ValueType Entry);
106
107 /// Return the destination virtual register of the last instruction
108 /// that loads from object Entry.
109 unsigned getReg(ValueType Entry);
110
111 /// Update ScopedHT.
112 void incCntAndSetReg(ValueType Entry, unsigned Reg);
113
114 ScopedHTType ScopedHT;
115
116 static char ID;
117};
118
119} // end of anonymous namespace
120
121char OptimizePICCall::ID = 0;
122
123/// Return the first MachineOperand of MI if it is a used virtual register.
125 if (MI.getNumOperands() == 0)
126 return nullptr;
127
128 MachineOperand &MO = MI.getOperand(0);
129
130 if (!MO.isReg() || !MO.isUse() || !MO.getReg().isVirtual())
131 return nullptr;
132
133 return &MO;
134}
135
136/// Return type of register Reg.
139 const TargetRegisterClass *RC = MF.getRegInfo().getRegClass(Reg);
140 assert(TRI.legalclasstypes_end(*RC) - TRI.legalclasstypes_begin(*RC) == 1);
141 return *TRI.legalclasstypes_begin(*RC);
142}
143
144/// Do the following transformation:
145///
146/// jalr $vreg
147/// =>
148/// copy $t9, $vreg
149/// jalr $t9
152 MachineFunction &MF = *MBB->getParent();
154 Register SrcReg = I->getOperand(0).getReg();
155 unsigned DstReg = getRegTy(SrcReg, MF) == MVT::i32 ? Mips::T9 : Mips::T9_64;
156 BuildMI(*MBB, I, I->getDebugLoc(), TII.get(TargetOpcode::COPY), DstReg)
157 .addReg(SrcReg);
158 I->getOperand(0).setReg(DstReg);
159}
160
161/// Search MI's operands for register GP and erase it.
163 if (!EraseGPOpnd)
164 return;
165
166 MachineFunction &MF = *MI.getParent()->getParent();
167 MVT::SimpleValueType Ty = getRegTy(MI.getOperand(0).getReg(), MF);
168 unsigned Reg = Ty == MVT::i32 ? Mips::GP : Mips::GP_64;
169
170 for (unsigned I = 0; I < MI.getNumOperands(); ++I) {
171 MachineOperand &MO = MI.getOperand(I);
172 if (MO.isReg() && MO.getReg() == Reg) {
173 MI.removeOperand(I);
174 return;
175 }
176 }
177
178 llvm_unreachable(nullptr);
179}
180
181MBBInfo::MBBInfo(MachineDomTreeNode *N) : Node(N), HTScope(nullptr) {}
182
183const MachineDomTreeNode *MBBInfo::getNode() const { return Node; }
184
185bool MBBInfo::isVisited() const { return HTScope; }
186
187void MBBInfo::preVisit(ScopedHTType &ScopedHT) {
188 HTScope = new ScopedHTType::ScopeTy(ScopedHT);
189}
190
191void MBBInfo::postVisit() {
192 delete HTScope;
193}
194
195// OptimizePICCall methods.
196bool OptimizePICCall::runOnMachineFunction(MachineFunction &F) {
197 if (F.getSubtarget<MipsSubtarget>().inMips16Mode())
198 return false;
199
200 // Do a pre-order traversal of the dominator tree.
201 MachineDominatorTree *MDT = &getAnalysis<MachineDominatorTree>();
202 bool Changed = false;
203
204 SmallVector<MBBInfo, 8> WorkList(1, MBBInfo(MDT->getRootNode()));
205
206 while (!WorkList.empty()) {
207 MBBInfo &MBBI = WorkList.back();
208
209 // If this MBB has already been visited, destroy the scope for the MBB and
210 // pop it from the work list.
211 if (MBBI.isVisited()) {
212 MBBI.postVisit();
213 WorkList.pop_back();
214 continue;
215 }
216
217 // Visit the MBB and add its children to the work list.
218 MBBI.preVisit(ScopedHT);
219 Changed |= visitNode(MBBI);
220 const MachineDomTreeNode *Node = MBBI.getNode();
221 WorkList.append(Node->begin(), Node->end());
222 }
223
224 return Changed;
225}
226
227bool OptimizePICCall::visitNode(MBBInfo &MBBI) {
228 bool Changed = false;
229 MachineBasicBlock *MBB = MBBI.getNode()->getBlock();
230
231 for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;
232 ++I) {
233 unsigned Reg;
234 ValueType Entry;
235
236 // Skip instructions that are not call instructions via registers.
237 if (!isCallViaRegister(*I, Reg, Entry))
238 continue;
239
240 Changed = true;
241 unsigned N = getCount(Entry);
242
243 if (N != 0) {
244 // If a function has been called more than twice, we do not have to emit a
245 // load instruction to get the function address from the GOT, but can
246 // instead reuse the address that has been loaded before.
247 if (N >= 2 && !LoadTargetFromGOT)
249
250 // Erase the $gp operand if this isn't the first time a function has
251 // been called. $gp needs to be set up only if the function call can go
252 // through a lazy binding stub.
253 eraseGPOpnd(*I);
254 }
255
256 if (Entry)
257 incCntAndSetReg(Entry, Reg);
258
260 }
261
262 return Changed;
263}
264
265bool OptimizePICCall::isCallViaRegister(MachineInstr &MI, unsigned &Reg,
266 ValueType &Val) const {
267 if (!MI.isCall())
268 return false;
269
271
272 // Return if MI is not a function call via a register.
273 if (!MO)
274 return false;
275
276 // Get the instruction that loads the function address from the GOT.
277 Reg = MO->getReg();
278 Val = nullptr;
279 MachineRegisterInfo &MRI = MI.getParent()->getParent()->getRegInfo();
280 MachineInstr *DefMI = MRI.getVRegDef(Reg);
281
282 assert(DefMI);
283
284 // See if DefMI is an instruction that loads from a GOT entry that holds the
285 // address of a lazy binding stub.
286 if (!DefMI->mayLoad() || DefMI->getNumOperands() < 3)
287 return true;
288
289 unsigned Flags = DefMI->getOperand(2).getTargetFlags();
290
291 if (Flags != MipsII::MO_GOT_CALL && Flags != MipsII::MO_CALL_LO16)
292 return true;
293
294 // Return the underlying object for the GOT entry in Val.
296 Val = (*DefMI->memoperands_begin())->getValue();
297 if (!Val)
298 Val = (*DefMI->memoperands_begin())->getPseudoValue();
299 return true;
300}
301
302unsigned OptimizePICCall::getCount(ValueType Entry) {
303 return ScopedHT.lookup(Entry).first;
304}
305
306unsigned OptimizePICCall::getReg(ValueType Entry) {
307 unsigned Reg = ScopedHT.lookup(Entry).second;
308 assert(Reg);
309 return Reg;
310}
311
312void OptimizePICCall::incCntAndSetReg(ValueType Entry, unsigned Reg) {
313 CntRegP P = ScopedHT.lookup(Entry);
314 ScopedHT.insert(Entry, std::make_pair(P.first + 1, Reg));
315}
316
317/// Return an OptimizeCall object.
319 return new OptimizePICCall();
320}
unsigned const MachineRegisterInfo * MRI
MachineInstrBuilder MachineInstrBuilder & DefMI
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned const TargetRegisterInfo * TRI
static unsigned getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
static cl::opt< bool > LoadTargetFromGOT("mips-load-target-from-got", cl::init(true), cl::desc("Load target address from GOT"), cl::Hidden)
static void setCallTargetReg(MachineBasicBlock *MBB, MachineBasicBlock::iterator I)
Do the following transformation:
static void eraseGPOpnd(MachineInstr &MI)
Search MI's operands for register GP and erase it.
static MachineOperand * getCallTargetRegOpnd(MachineInstr &MI)
Return the first MachineOperand of MI if it is a used virtual register.
static cl::opt< bool > EraseGPOpnd("mips-erase-gp-opnd", cl::init(true), cl::desc("Erase GP Operand"), cl::Hidden)
static MVT::SimpleValueType getRegTy(unsigned Reg, MachineFunction &MF)
Return type of register Reg.
#define P(N)
This file defines the PointerUnion class, which is a discriminated union of pointer types.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
Base class for the actual dominator tree node.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineDomTreeNode * getRootNode() const
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
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.
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Representation of each machine instruction.
Definition: MachineInstr.h:68
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:546
bool mayLoad(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read memory.
bool hasOneMemOperand() const
Return true if this instruction has exactly one MachineMemOperand.
Definition: MachineInstr.h:789
mmo_iterator memoperands_begin() const
Access to memory operands of the instruction.
Definition: MachineInstr.h:774
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:553
MachineOperand class - Representation of each machine instruction operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
void setReg(Register Reg)
Change the register this operand corresponds to.
unsigned getTargetFlags() const
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
bool inMips16Mode() const
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
RecyclingAllocator - This class wraps an Allocator, adding the functionality of recycling deleted obj...
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
Definition: Register.h:91
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
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
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ MO_GOT_CALL
MO_GOT_CALL - Represents the offset into the global offset table at which the address of a call site ...
Definition: MipsBaseInfo.h:44
Reg
All possible values of the reg field in the ModR/M byte.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:445
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
FunctionPass * createMipsOptimizePICCallPass()
Return an OptimizeCall object.
BumpPtrAllocatorImpl BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition: Allocator.h:375
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
#define N
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: DenseMapInfo.h:50