Fix PR 7087, and probably other things, by extending
[oota-llvm.git] / lib / CodeGen / LowerSubregs.cpp
1 //===-- LowerSubregs.cpp - Subregister Lowering instruction pass ----------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
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.
14 //
15 //===----------------------------------------------------------------------===//
16
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"
29 using namespace llvm;
30
31 namespace {
32   struct LowerSubregsInstructionPass : public MachineFunctionPass {
33   private:
34     const TargetRegisterInfo *TRI;
35     const TargetInstrInfo *TII;
36
37   public:
38     static char ID; // Pass identification, replacement for typeid
39     LowerSubregsInstructionPass() : MachineFunctionPass(&ID) {}
40     
41     const char *getPassName() const {
42       return "Subregister lowering instruction pass";
43     }
44
45     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
46       AU.setPreservesCFG();
47       AU.addPreservedID(MachineLoopInfoID);
48       AU.addPreservedID(MachineDominatorsID);
49       MachineFunctionPass::getAnalysisUsage(AU);
50     }
51
52     /// runOnMachineFunction - pass entry point
53     bool runOnMachineFunction(MachineFunction&);
54
55   private:
56     bool LowerExtract(MachineInstr *MI);
57     bool LowerInsert(MachineInstr *MI);
58     bool LowerSubregToReg(MachineInstr *MI);
59
60     void TransferDeadFlag(MachineInstr *MI, unsigned DstReg,
61                           const TargetRegisterInfo *TRI);
62     void TransferKillFlag(MachineInstr *MI, unsigned SrcReg,
63                           const TargetRegisterInfo *TRI,
64                           bool AddIfNotFound = false);
65   };
66
67   char LowerSubregsInstructionPass::ID = 0;
68 }
69
70 FunctionPass *llvm::createLowerSubregsPass() { 
71   return new LowerSubregsInstructionPass(); 
72 }
73
74 /// TransferDeadFlag - MI is a pseudo-instruction with DstReg dead,
75 /// and the lowered replacement instructions immediately precede it.
76 /// Mark the replacement instructions with the dead flag.
77 void
78 LowerSubregsInstructionPass::TransferDeadFlag(MachineInstr *MI,
79                                               unsigned DstReg,
80                                               const TargetRegisterInfo *TRI) {
81   for (MachineBasicBlock::iterator MII =
82         prior(MachineBasicBlock::iterator(MI)); ; --MII) {
83     if (MII->addRegisterDead(DstReg, TRI))
84       break;
85     assert(MII != MI->getParent()->begin() &&
86            "copyRegToReg output doesn't reference destination register!");
87   }
88 }
89
90 /// TransferKillFlag - MI is a pseudo-instruction with SrcReg killed,
91 /// and the lowered replacement instructions immediately precede it.
92 /// Mark the replacement instructions with the kill flag.
93 void
94 LowerSubregsInstructionPass::TransferKillFlag(MachineInstr *MI,
95                                               unsigned SrcReg,
96                                               const TargetRegisterInfo *TRI,
97                                               bool AddIfNotFound) {
98   for (MachineBasicBlock::iterator MII =
99         prior(MachineBasicBlock::iterator(MI)); ; --MII) {
100     if (MII->addRegisterKilled(SrcReg, TRI, AddIfNotFound))
101       break;
102     assert(MII != MI->getParent()->begin() &&
103            "copyRegToReg output doesn't reference source register!");
104   }
105 }
106
107 bool LowerSubregsInstructionPass::LowerExtract(MachineInstr *MI) {
108   MachineBasicBlock *MBB = MI->getParent();
109
110   assert(MI->getOperand(0).isReg() && MI->getOperand(0).isDef() &&
111          MI->getOperand(1).isReg() && MI->getOperand(1).isUse() &&
112          MI->getOperand(2).isImm() && "Malformed extract_subreg");
113
114   unsigned DstReg   = MI->getOperand(0).getReg();
115   unsigned SuperReg = MI->getOperand(1).getReg();
116   unsigned SubIdx   = MI->getOperand(2).getImm();
117   unsigned SrcReg   = TRI->getSubReg(SuperReg, SubIdx);
118
119   assert(TargetRegisterInfo::isPhysicalRegister(SuperReg) &&
120          "Extract supperg source must be a physical register");
121   assert(TargetRegisterInfo::isPhysicalRegister(DstReg) &&
122          "Extract destination must be in a physical register");
123   assert(SrcReg && "invalid subregister index for register");
124
125   DEBUG(dbgs() << "subreg: CONVERTING: " << *MI);
126
127   if (SrcReg == DstReg) {
128     // No need to insert an identity copy instruction.
129     if (MI->getOperand(1).isKill()) {
130       // We must make sure the super-register gets killed. Replace the
131       // instruction with KILL.
132       MI->setDesc(TII->get(TargetOpcode::KILL));
133       MI->RemoveOperand(2);     // SubIdx
134       DEBUG(dbgs() << "subreg: replace by: " << *MI);
135       return true;
136     }
137
138     DEBUG(dbgs() << "subreg: eliminated!");
139   } else {
140     // Insert copy
141     const TargetRegisterClass *TRCS = TRI->getPhysicalRegisterRegClass(DstReg);
142     const TargetRegisterClass *TRCD = TRI->getPhysicalRegisterRegClass(SrcReg);
143     bool Emitted = TII->copyRegToReg(*MBB, MI, DstReg, SrcReg, TRCD, TRCS,
144                                      MI->getDebugLoc());
145     (void)Emitted;
146     assert(Emitted && "Subreg and Dst must be of compatible register class");
147     // Transfer the kill/dead flags, if needed.
148     if (MI->getOperand(0).isDead())
149       TransferDeadFlag(MI, DstReg, TRI);
150     if (MI->getOperand(1).isKill())
151       TransferKillFlag(MI, SuperReg, TRI, true);
152     DEBUG({
153         MachineBasicBlock::iterator dMI = MI;
154         dbgs() << "subreg: " << *(--dMI);
155       });
156   }
157
158   DEBUG(dbgs() << '\n');
159   MBB->erase(MI);
160   return true;
161 }
162
163 bool LowerSubregsInstructionPass::LowerSubregToReg(MachineInstr *MI) {
164   MachineBasicBlock *MBB = MI->getParent();
165   assert((MI->getOperand(0).isReg() && MI->getOperand(0).isDef()) &&
166          MI->getOperand(1).isImm() &&
167          (MI->getOperand(2).isReg() && MI->getOperand(2).isUse()) &&
168           MI->getOperand(3).isImm() && "Invalid subreg_to_reg");
169           
170   unsigned DstReg  = MI->getOperand(0).getReg();
171   unsigned InsReg  = MI->getOperand(2).getReg();
172   unsigned InsSIdx = MI->getOperand(2).getSubReg();
173   unsigned SubIdx  = MI->getOperand(3).getImm();
174
175   assert(SubIdx != 0 && "Invalid index for insert_subreg");
176   unsigned DstSubReg = TRI->getSubReg(DstReg, SubIdx);
177
178   assert(TargetRegisterInfo::isPhysicalRegister(DstReg) &&
179          "Insert destination must be in a physical register");
180   assert(TargetRegisterInfo::isPhysicalRegister(InsReg) &&
181          "Inserted value must be in a physical register");
182
183   DEBUG(dbgs() << "subreg: CONVERTING: " << *MI);
184
185   if (DstSubReg == InsReg && InsSIdx == 0) {
186     // No need to insert an identify copy instruction.
187     // Watch out for case like this:
188     // %RAX<def> = ...
189     // %RAX<def> = SUBREG_TO_REG 0, %EAX:3<kill>, 3
190     // The first def is defining RAX, not EAX so the top bits were not
191     // zero extended.
192     DEBUG(dbgs() << "subreg: eliminated!");
193   } else {
194     // Insert sub-register copy
195     const TargetRegisterClass *TRC0= TRI->getPhysicalRegisterRegClass(DstSubReg);
196     const TargetRegisterClass *TRC1= TRI->getPhysicalRegisterRegClass(InsReg);
197     bool Emitted = TII->copyRegToReg(*MBB, MI, DstSubReg, InsReg, TRC0, TRC1,
198                                      MI->getDebugLoc());
199     (void)Emitted;
200     assert(Emitted && "Subreg and Dst must be of compatible register class");
201     // Transfer the kill/dead flags, if needed.
202     if (MI->getOperand(0).isDead())
203       TransferDeadFlag(MI, DstSubReg, TRI);
204     if (MI->getOperand(2).isKill())
205       TransferKillFlag(MI, InsReg, TRI);
206     DEBUG({
207         MachineBasicBlock::iterator dMI = MI;
208         dbgs() << "subreg: " << *(--dMI);
209       });
210   }
211
212   DEBUG(dbgs() << '\n');
213   MBB->erase(MI);
214   return true;
215 }
216
217 bool LowerSubregsInstructionPass::LowerInsert(MachineInstr *MI) {
218   MachineBasicBlock *MBB = MI->getParent();
219   assert((MI->getOperand(0).isReg() && MI->getOperand(0).isDef()) &&
220          (MI->getOperand(1).isReg() && MI->getOperand(1).isUse()) &&
221          (MI->getOperand(2).isReg() && MI->getOperand(2).isUse()) &&
222           MI->getOperand(3).isImm() && "Invalid insert_subreg");
223           
224   unsigned DstReg = MI->getOperand(0).getReg();
225 #ifndef NDEBUG
226   unsigned SrcReg = MI->getOperand(1).getReg();
227 #endif
228   unsigned InsReg = MI->getOperand(2).getReg();
229   unsigned SubIdx = MI->getOperand(3).getImm();     
230
231   assert(DstReg == SrcReg && "insert_subreg not a two-address instruction?");
232   assert(SubIdx != 0 && "Invalid index for insert_subreg");
233   unsigned DstSubReg = TRI->getSubReg(DstReg, SubIdx);
234   assert(DstSubReg && "invalid subregister index for register");
235   assert(TargetRegisterInfo::isPhysicalRegister(SrcReg) &&
236          "Insert superreg source must be in a physical register");
237   assert(TargetRegisterInfo::isPhysicalRegister(InsReg) &&
238          "Inserted value must be in a physical register");
239
240   DEBUG(dbgs() << "subreg: CONVERTING: " << *MI);
241
242   if (DstSubReg == InsReg) {
243     // No need to insert an identity copy instruction. If the SrcReg was
244     // <undef>, we need to make sure it is alive by inserting a KILL
245     if (MI->getOperand(1).isUndef() && !MI->getOperand(0).isDead()) {
246       MachineInstrBuilder MIB = BuildMI(*MBB, MI, MI->getDebugLoc(),
247                                 TII->get(TargetOpcode::KILL), DstReg);
248       if (MI->getOperand(2).isUndef())
249         MIB.addReg(InsReg, RegState::Undef);
250       else
251         MIB.addReg(InsReg, RegState::Kill);
252     } else {
253       DEBUG(dbgs() << "subreg: eliminated!\n");
254       MBB->erase(MI);
255       return true;
256     }
257   } else {
258     // Insert sub-register copy
259     const TargetRegisterClass *TRC0= TRI->getPhysicalRegisterRegClass(DstSubReg);
260     const TargetRegisterClass *TRC1= TRI->getPhysicalRegisterRegClass(InsReg);
261     if (MI->getOperand(2).isUndef())
262       // If the source register being inserted is undef, then this becomes a
263       // KILL.
264       BuildMI(*MBB, MI, MI->getDebugLoc(),
265               TII->get(TargetOpcode::KILL), DstSubReg);
266     else {
267       bool Emitted = TII->copyRegToReg(*MBB, MI, DstSubReg, InsReg, TRC0, TRC1,
268                                        MI->getDebugLoc());
269       (void)Emitted;
270       assert(Emitted && "Subreg and Dst must be of compatible register class");
271     }
272     MachineBasicBlock::iterator CopyMI = MI;
273     --CopyMI;
274
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));
278
279     // Transfer the kill/dead flags, if needed.
280     if (MI->getOperand(0).isDead()) {
281       TransferDeadFlag(MI, DstSubReg, TRI);
282     } else {
283       // Make sure the full DstReg is live after this replacement.
284       CopyMI->addOperand(MachineOperand::CreateReg(DstReg, true, true));
285     }
286
287     // Make sure the inserted register gets killed
288     if (MI->getOperand(2).isKill() && !MI->getOperand(2).isUndef())
289       TransferKillFlag(MI, InsReg, TRI);
290   }
291
292   DEBUG({
293       MachineBasicBlock::iterator dMI = MI;
294       dbgs() << "subreg: " << *(--dMI) << "\n";
295     });
296
297   MBB->erase(MI);
298   return true;
299 }
300
301 /// runOnMachineFunction - Reduce subregister inserts and extracts to register
302 /// copies.
303 ///
304 bool LowerSubregsInstructionPass::runOnMachineFunction(MachineFunction &MF) {
305   DEBUG(dbgs() << "Machine Function\n"  
306                << "********** LOWERING SUBREG INSTRS **********\n"
307                << "********** Function: " 
308                << MF.getFunction()->getName() << '\n');
309   TRI = MF.getTarget().getRegisterInfo();
310   TII = MF.getTarget().getInstrInfo();
311
312   bool MadeChange = false;
313
314   for (MachineFunction::iterator mbbi = MF.begin(), mbbe = MF.end();
315        mbbi != mbbe; ++mbbi) {
316     for (MachineBasicBlock::iterator mi = mbbi->begin(), me = mbbi->end();
317          mi != me;) {
318       MachineBasicBlock::iterator nmi = llvm::next(mi);
319       MachineInstr *MI = mi;
320       if (MI->isExtractSubreg()) {
321         MadeChange |= LowerExtract(MI);
322       } else if (MI->isInsertSubreg()) {
323         MadeChange |= LowerInsert(MI);
324       } else if (MI->isSubregToReg()) {
325         MadeChange |= LowerSubregToReg(MI);
326       }
327       mi = nmi;
328     }
329   }
330
331   return MadeChange;
332 }