1 //===-- LowerSubregs.cpp - Subregister Lowering instruction pass ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a MachineFunction pass which runs after register
11 // allocation that turns subreg insert/extract instructions into register
12 // copies, as needed. This ensures correct codegen even if the coalescer
13 // isn't able to remove all subreg instructions.
15 //===----------------------------------------------------------------------===//
17 #define DEBUG_TYPE "lowersubregs"
18 #include "llvm/CodeGen/Passes.h"
19 #include "llvm/Function.h"
20 #include "llvm/CodeGen/MachineFunctionPass.h"
21 #include "llvm/CodeGen/MachineInstr.h"
22 #include "llvm/CodeGen/MachineInstrBuilder.h"
23 #include "llvm/CodeGen/MachineRegisterInfo.h"
24 #include "llvm/Target/TargetRegisterInfo.h"
25 #include "llvm/Target/TargetInstrInfo.h"
26 #include "llvm/Target/TargetMachine.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/raw_ostream.h"
32 struct LowerSubregsInstructionPass
: public MachineFunctionPass
{
33 static char ID
; // Pass identification, replacement for typeid
34 LowerSubregsInstructionPass() : MachineFunctionPass(&ID
) {}
36 const char *getPassName() const {
37 return "Subregister lowering instruction pass";
40 virtual void getAnalysisUsage(AnalysisUsage
&AU
) const {
42 AU
.addPreservedID(MachineLoopInfoID
);
43 AU
.addPreservedID(MachineDominatorsID
);
44 MachineFunctionPass::getAnalysisUsage(AU
);
47 /// runOnMachineFunction - pass entry point
48 bool runOnMachineFunction(MachineFunction
&);
50 bool LowerExtract(MachineInstr
*MI
);
51 bool LowerInsert(MachineInstr
*MI
);
52 bool LowerSubregToReg(MachineInstr
*MI
);
54 void TransferDeadFlag(MachineInstr
*MI
, unsigned DstReg
,
55 const TargetRegisterInfo
&TRI
);
56 void TransferKillFlag(MachineInstr
*MI
, unsigned SrcReg
,
57 const TargetRegisterInfo
&TRI
,
58 bool AddIfNotFound
= false);
61 char LowerSubregsInstructionPass::ID
= 0;
64 FunctionPass
*llvm::createLowerSubregsPass() {
65 return new LowerSubregsInstructionPass();
68 /// TransferDeadFlag - MI is a pseudo-instruction with DstReg dead,
69 /// and the lowered replacement instructions immediately precede it.
70 /// Mark the replacement instructions with the dead flag.
72 LowerSubregsInstructionPass::TransferDeadFlag(MachineInstr
*MI
,
74 const TargetRegisterInfo
&TRI
) {
75 for (MachineBasicBlock::iterator MII
=
76 prior(MachineBasicBlock::iterator(MI
)); ; --MII
) {
77 if (MII
->addRegisterDead(DstReg
, &TRI
))
79 assert(MII
!= MI
->getParent()->begin() &&
80 "copyRegToReg output doesn't reference destination register!");
84 /// TransferKillFlag - MI is a pseudo-instruction with SrcReg killed,
85 /// and the lowered replacement instructions immediately precede it.
86 /// Mark the replacement instructions with the kill flag.
88 LowerSubregsInstructionPass::TransferKillFlag(MachineInstr
*MI
,
90 const TargetRegisterInfo
&TRI
,
92 for (MachineBasicBlock::iterator MII
=
93 prior(MachineBasicBlock::iterator(MI
)); ; --MII
) {
94 if (MII
->addRegisterKilled(SrcReg
, &TRI
, AddIfNotFound
))
96 assert(MII
!= MI
->getParent()->begin() &&
97 "copyRegToReg output doesn't reference source register!");
101 bool LowerSubregsInstructionPass::LowerExtract(MachineInstr
*MI
) {
102 MachineBasicBlock
*MBB
= MI
->getParent();
103 MachineFunction
&MF
= *MBB
->getParent();
104 const TargetRegisterInfo
&TRI
= *MF
.getTarget().getRegisterInfo();
105 const TargetInstrInfo
&TII
= *MF
.getTarget().getInstrInfo();
107 assert(MI
->getOperand(0).isReg() && MI
->getOperand(0).isDef() &&
108 MI
->getOperand(1).isReg() && MI
->getOperand(1).isUse() &&
109 MI
->getOperand(2).isImm() && "Malformed extract_subreg");
111 unsigned DstReg
= MI
->getOperand(0).getReg();
112 unsigned SuperReg
= MI
->getOperand(1).getReg();
113 unsigned SubIdx
= MI
->getOperand(2).getImm();
114 unsigned SrcReg
= TRI
.getSubReg(SuperReg
, SubIdx
);
116 assert(TargetRegisterInfo::isPhysicalRegister(SuperReg
) &&
117 "Extract supperg source must be a physical register");
118 assert(TargetRegisterInfo::isPhysicalRegister(DstReg
) &&
119 "Extract destination must be in a physical register");
120 assert(SrcReg
&& "invalid subregister index for register");
122 DEBUG(errs() << "subreg: CONVERTING: " << *MI
);
124 if (SrcReg
== DstReg
) {
125 // No need to insert an identity copy instruction.
126 if (MI
->getOperand(1).isKill()) {
127 // We must make sure the super-register gets killed. Replace the
128 // instruction with KILL.
129 MI
->setDesc(TII
.get(TargetInstrInfo::KILL
));
130 MI
->RemoveOperand(2); // SubIdx
131 DEBUG(errs() << "subreg: replace by: " << *MI
);
135 DEBUG(errs() << "subreg: eliminated!");
138 const TargetRegisterClass
*TRCS
= TRI
.getPhysicalRegisterRegClass(DstReg
);
139 const TargetRegisterClass
*TRCD
= TRI
.getPhysicalRegisterRegClass(SrcReg
);
140 bool Emitted
= TII
.copyRegToReg(*MBB
, MI
, DstReg
, SrcReg
, TRCD
, TRCS
);
142 assert(Emitted
&& "Subreg and Dst must be of compatible register class");
143 // Transfer the kill/dead flags, if needed.
144 if (MI
->getOperand(0).isDead())
145 TransferDeadFlag(MI
, DstReg
, TRI
);
146 if (MI
->getOperand(1).isKill())
147 TransferKillFlag(MI
, SuperReg
, TRI
, true);
149 MachineBasicBlock::iterator dMI
= MI
;
150 errs() << "subreg: " << *(--dMI
);
154 DEBUG(errs() << '\n');
159 bool LowerSubregsInstructionPass::LowerSubregToReg(MachineInstr
*MI
) {
160 MachineBasicBlock
*MBB
= MI
->getParent();
161 MachineFunction
&MF
= *MBB
->getParent();
162 const TargetRegisterInfo
&TRI
= *MF
.getTarget().getRegisterInfo();
163 const TargetInstrInfo
&TII
= *MF
.getTarget().getInstrInfo();
164 assert((MI
->getOperand(0).isReg() && MI
->getOperand(0).isDef()) &&
165 MI
->getOperand(1).isImm() &&
166 (MI
->getOperand(2).isReg() && MI
->getOperand(2).isUse()) &&
167 MI
->getOperand(3).isImm() && "Invalid subreg_to_reg");
169 unsigned DstReg
= MI
->getOperand(0).getReg();
170 unsigned InsReg
= MI
->getOperand(2).getReg();
171 unsigned InsSIdx
= MI
->getOperand(2).getSubReg();
172 unsigned SubIdx
= MI
->getOperand(3).getImm();
174 assert(SubIdx
!= 0 && "Invalid index for insert_subreg");
175 unsigned DstSubReg
= TRI
.getSubReg(DstReg
, SubIdx
);
177 assert(TargetRegisterInfo::isPhysicalRegister(DstReg
) &&
178 "Insert destination must be in a physical register");
179 assert(TargetRegisterInfo::isPhysicalRegister(InsReg
) &&
180 "Inserted value must be in a physical register");
182 DEBUG(errs() << "subreg: CONVERTING: " << *MI
);
184 if (DstSubReg
== InsReg
&& InsSIdx
== 0) {
185 // No need to insert an identify copy instruction.
186 // Watch out for case like this:
188 // %RAX<def> = SUBREG_TO_REG 0, %EAX:3<kill>, 3
189 // The first def is defining RAX, not EAX so the top bits were not
191 DEBUG(errs() << "subreg: eliminated!");
193 // Insert sub-register copy
194 const TargetRegisterClass
*TRC0
= TRI
.getPhysicalRegisterRegClass(DstSubReg
);
195 const TargetRegisterClass
*TRC1
= TRI
.getPhysicalRegisterRegClass(InsReg
);
196 bool Emitted
= TII
.copyRegToReg(*MBB
, MI
, DstSubReg
, InsReg
, TRC0
, TRC1
);
198 assert(Emitted
&& "Subreg and Dst must be of compatible register class");
199 // Transfer the kill/dead flags, if needed.
200 if (MI
->getOperand(0).isDead())
201 TransferDeadFlag(MI
, DstSubReg
, TRI
);
202 if (MI
->getOperand(2).isKill())
203 TransferKillFlag(MI
, InsReg
, TRI
);
205 MachineBasicBlock::iterator dMI
= MI
;
206 errs() << "subreg: " << *(--dMI
);
210 DEBUG(errs() << '\n');
215 bool LowerSubregsInstructionPass::LowerInsert(MachineInstr
*MI
) {
216 MachineBasicBlock
*MBB
= MI
->getParent();
217 MachineFunction
&MF
= *MBB
->getParent();
218 const TargetRegisterInfo
&TRI
= *MF
.getTarget().getRegisterInfo();
219 const TargetInstrInfo
&TII
= *MF
.getTarget().getInstrInfo();
220 assert((MI
->getOperand(0).isReg() && MI
->getOperand(0).isDef()) &&
221 (MI
->getOperand(1).isReg() && MI
->getOperand(1).isUse()) &&
222 (MI
->getOperand(2).isReg() && MI
->getOperand(2).isUse()) &&
223 MI
->getOperand(3).isImm() && "Invalid insert_subreg");
225 unsigned DstReg
= MI
->getOperand(0).getReg();
227 unsigned SrcReg
= MI
->getOperand(1).getReg();
229 unsigned InsReg
= MI
->getOperand(2).getReg();
230 unsigned SubIdx
= MI
->getOperand(3).getImm();
232 assert(DstReg
== SrcReg
&& "insert_subreg not a two-address instruction?");
233 assert(SubIdx
!= 0 && "Invalid index for insert_subreg");
234 unsigned DstSubReg
= TRI
.getSubReg(DstReg
, SubIdx
);
235 assert(DstSubReg
&& "invalid subregister index for register");
236 assert(TargetRegisterInfo::isPhysicalRegister(SrcReg
) &&
237 "Insert superreg source must be in a physical register");
238 assert(TargetRegisterInfo::isPhysicalRegister(InsReg
) &&
239 "Inserted value must be in a physical register");
241 DEBUG(errs() << "subreg: CONVERTING: " << *MI
);
243 if (DstSubReg
== InsReg
) {
244 // No need to insert an identity copy instruction. If the SrcReg was
245 // <undef>, we need to make sure it is alive by inserting a KILL
246 if (MI
->getOperand(1).isUndef() && !MI
->getOperand(0).isDead()) {
247 MachineInstrBuilder MIB
= BuildMI(*MBB
, MI
, MI
->getDebugLoc(),
248 TII
.get(TargetInstrInfo::KILL
), DstReg
);
249 if (MI
->getOperand(2).isUndef())
250 MIB
.addReg(InsReg
, RegState::Undef
);
252 MIB
.addReg(InsReg
, RegState::Kill
);
254 DEBUG(errs() << "subreg: eliminated!\n");
259 // Insert sub-register copy
260 const TargetRegisterClass
*TRC0
= TRI
.getPhysicalRegisterRegClass(DstSubReg
);
261 const TargetRegisterClass
*TRC1
= TRI
.getPhysicalRegisterRegClass(InsReg
);
262 if (MI
->getOperand(2).isUndef())
263 // If the source register being inserted is undef, then this becomes a
265 BuildMI(*MBB
, MI
, MI
->getDebugLoc(),
266 TII
.get(TargetInstrInfo::KILL
), DstSubReg
);
268 bool Emitted
= TII
.copyRegToReg(*MBB
, MI
, DstSubReg
, InsReg
, TRC0
, TRC1
);
270 assert(Emitted
&& "Subreg and Dst must be of compatible register class");
272 MachineBasicBlock::iterator CopyMI
= MI
;
275 // INSERT_SUBREG is a two-address instruction so it implicitly kills SrcReg.
276 if (!MI
->getOperand(1).isUndef())
277 CopyMI
->addOperand(MachineOperand::CreateReg(DstReg
, false, true, true));
279 // Transfer the kill/dead flags, if needed.
280 if (MI
->getOperand(0).isDead()) {
281 TransferDeadFlag(MI
, DstSubReg
, TRI
);
283 // Make sure the full DstReg is live after this replacement.
284 CopyMI
->addOperand(MachineOperand::CreateReg(DstReg
, true, true));
287 // Make sure the inserted register gets killed
288 if (MI
->getOperand(2).isKill() && !MI
->getOperand(2).isUndef())
289 TransferKillFlag(MI
, InsReg
, TRI
);
293 MachineBasicBlock::iterator dMI
= MI
;
294 errs() << "subreg: " << *(--dMI
) << "\n";
301 /// runOnMachineFunction - Reduce subregister inserts and extracts to register
304 bool LowerSubregsInstructionPass::runOnMachineFunction(MachineFunction
&MF
) {
305 DEBUG(errs() << "Machine Function\n"
306 << "********** LOWERING SUBREG INSTRS **********\n"
307 << "********** Function: "
308 << MF
.getFunction()->getName() << '\n');
310 bool MadeChange
= false;
312 for (MachineFunction::iterator mbbi
= MF
.begin(), mbbe
= MF
.end();
313 mbbi
!= mbbe
; ++mbbi
) {
314 for (MachineBasicBlock::iterator mi
= mbbi
->begin(), me
= mbbi
->end();
316 MachineInstr
*MI
= mi
++;
318 if (MI
->getOpcode() == TargetInstrInfo::EXTRACT_SUBREG
) {
319 MadeChange
|= LowerExtract(MI
);
320 } else if (MI
->getOpcode() == TargetInstrInfo::INSERT_SUBREG
) {
321 MadeChange
|= LowerInsert(MI
);
322 } else if (MI
->getOpcode() == TargetInstrInfo::SUBREG_TO_REG
) {
323 MadeChange
|= LowerSubregToReg(MI
);