1 //===- MipsInstrInfo.cpp - Mips Instruction Information ---------*- C++ -*-===//
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 contains the Mips implementation of the TargetInstrInfo class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "MipsInstrInfo.h"
15 #include "MipsTargetMachine.h"
16 #include "MipsMachineFunction.h"
17 #include "InstPrinter/MipsInstPrinter.h"
18 #include "llvm/CodeGen/MachineInstrBuilder.h"
19 #include "llvm/CodeGen/MachineRegisterInfo.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/TargetRegistry.h"
22 #include "llvm/ADT/STLExtras.h"
23 
24 #define GET_INSTRINFO_CTOR
25 #include "MipsGenInstrInfo.inc"
26 
27 using namespace llvm;
28 
29 MipsInstrInfo::MipsInstrInfo(MipsTargetMachine &tm)
30   : MipsGenInstrInfo(Mips::ADJCALLSTACKDOWN, Mips::ADJCALLSTACKUP),
31     TM(tm), IsN64(TM.getSubtarget<MipsSubtarget>().isABI_N64()),
32     RI(*TM.getSubtargetImpl(), *this),
33     UncondBrOpc(TM.getRelocationModel() == Reloc::PIC_ ? Mips::B : Mips::J) {}
34 
35 const MipsRegisterInfo &MipsInstrInfo::getRegisterInfo() const {
36   return RI;
37 }
38 
39 static bool isZeroImm(const MachineOperand &op) {
40   return op.isImm() && op.getImm() == 0;
41 }
42 
43 /// isLoadFromStackSlot - If the specified machine instruction is a direct
44 /// load from a stack slot, return the virtual or physical register number of
45 /// the destination along with the FrameIndex of the loaded stack slot.  If
46 /// not, return 0.  This predicate must return 0 if the instruction has
47 /// any side effects other than loading from the stack slot.
48 unsigned MipsInstrInfo::
49 isLoadFromStackSlot(const MachineInstr *MI, int &FrameIndex) const
50 {
51   unsigned Opc = MI->getOpcode();
52 
53   if ((Opc == Mips::LW)    || (Opc == Mips::LW_P8)  || (Opc == Mips::LD) ||
54       (Opc == Mips::LD_P8) || (Opc == Mips::LWC1)   || (Opc == Mips::LWC1_P8) ||
55       (Opc == Mips::LDC1)  || (Opc == Mips::LDC164) ||
56       (Opc == Mips::LDC164_P8)) {
57     if ((MI->getOperand(1).isFI()) && // is a stack slot
58         (MI->getOperand(2).isImm()) &&  // the imm is zero
59         (isZeroImm(MI->getOperand(2)))) {
60       FrameIndex = MI->getOperand(1).getIndex();
61       return MI->getOperand(0).getReg();
62     }
63   }
64 
65   return 0;
66 }
67 
68 /// isStoreToStackSlot - If the specified machine instruction is a direct
69 /// store to a stack slot, return the virtual or physical register number of
70 /// the source reg along with the FrameIndex of the loaded stack slot.  If
71 /// not, return 0.  This predicate must return 0 if the instruction has
72 /// any side effects other than storing to the stack slot.
73 unsigned MipsInstrInfo::
74 isStoreToStackSlot(const MachineInstr *MI, int &FrameIndex) const
75 {
76   unsigned Opc = MI->getOpcode();
77 
78   if ((Opc == Mips::SW)    || (Opc == Mips::SW_P8)  || (Opc == Mips::SD) ||
79       (Opc == Mips::SD_P8) || (Opc == Mips::SWC1)   || (Opc == Mips::SWC1_P8) ||
80       (Opc == Mips::SDC1)  || (Opc == Mips::SDC164) ||
81       (Opc == Mips::SDC164_P8)) {
82     if ((MI->getOperand(1).isFI()) && // is a stack slot
83         (MI->getOperand(2).isImm()) &&  // the imm is zero
84         (isZeroImm(MI->getOperand(2)))) {
85       FrameIndex = MI->getOperand(1).getIndex();
86       return MI->getOperand(0).getReg();
87     }
88   }
89   return 0;
90 }
91 
92 /// insertNoop - If data hazard condition is found insert the target nop
93 /// instruction.
94 void MipsInstrInfo::
95 insertNoop(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const
96 {
97   DebugLoc DL;
98   BuildMI(MBB, MI, DL, get(Mips::NOP));
99 }
100 
101 void MipsInstrInfo::
102 copyPhysReg(MachineBasicBlock &MBB,
103             MachineBasicBlock::iterator I, DebugLoc DL,
104             unsigned DestReg, unsigned SrcReg,
105             bool KillSrc) const {
106   unsigned Opc = 0, ZeroReg = 0;
107 
108   if (Mips::CPURegsRegClass.contains(DestReg)) { // Copy to CPU Reg.
109     if (Mips::CPURegsRegClass.contains(SrcReg))
110       Opc = Mips::ADDu, ZeroReg = Mips::ZERO;
111     else if (Mips::CCRRegClass.contains(SrcReg))
112       Opc = Mips::CFC1;
113     else if (Mips::FGR32RegClass.contains(SrcReg))
114       Opc = Mips::MFC1;
115     else if (SrcReg == Mips::HI)
116       Opc = Mips::MFHI, SrcReg = 0;
117     else if (SrcReg == Mips::LO)
118       Opc = Mips::MFLO, SrcReg = 0;
119   }
120   else if (Mips::CPURegsRegClass.contains(SrcReg)) { // Copy from CPU Reg.
121     if (Mips::CCRRegClass.contains(DestReg))
122       Opc = Mips::CTC1;
123     else if (Mips::FGR32RegClass.contains(DestReg))
124       Opc = Mips::MTC1;
125     else if (DestReg == Mips::HI)
126       Opc = Mips::MTHI, DestReg = 0;
127     else if (DestReg == Mips::LO)
128       Opc = Mips::MTLO, DestReg = 0;
129   }
130   else if (Mips::FGR32RegClass.contains(DestReg, SrcReg))
131     Opc = Mips::FMOV_S;
132   else if (Mips::AFGR64RegClass.contains(DestReg, SrcReg))
133     Opc = Mips::FMOV_D32;
134   else if (Mips::FGR64RegClass.contains(DestReg, SrcReg))
135     Opc = Mips::FMOV_D64;
136   else if (Mips::CCRRegClass.contains(DestReg, SrcReg))
137     Opc = Mips::MOVCCRToCCR;
138   else if (Mips::CPU64RegsRegClass.contains(DestReg)) { // Copy to CPU64 Reg.
139     if (Mips::CPU64RegsRegClass.contains(SrcReg))
140       Opc = Mips::DADDu, ZeroReg = Mips::ZERO_64;
141     else if (SrcReg == Mips::HI64)
142       Opc = Mips::MFHI64, SrcReg = 0;
143     else if (SrcReg == Mips::LO64)
144       Opc = Mips::MFLO64, SrcReg = 0;
145     else if (Mips::FGR64RegClass.contains(SrcReg))
146       Opc = Mips::DMFC1;
147   }
148   else if (Mips::CPU64RegsRegClass.contains(SrcReg)) { // Copy from CPU64 Reg.
149     if (DestReg == Mips::HI64)
150       Opc = Mips::MTHI64, DestReg = 0;
151     else if (DestReg == Mips::LO64)
152       Opc = Mips::MTLO64, DestReg = 0;
153     else if (Mips::FGR64RegClass.contains(DestReg))
154       Opc = Mips::DMTC1;
155   }
156 
157   assert(Opc && "Cannot copy registers");
158 
159   MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opc));
160 
161   if (DestReg)
162     MIB.addReg(DestReg, RegState::Define);
163 
164   if (ZeroReg)
165     MIB.addReg(ZeroReg);
166 
167   if (SrcReg)
168     MIB.addReg(SrcReg, getKillRegState(KillSrc));
169 }
170 
171 void MipsInstrInfo::
172 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
173                     unsigned SrcReg, bool isKill, int FI,
174                     const TargetRegisterClass *RC,
175                     const TargetRegisterInfo *TRI) const {
176   DebugLoc DL;
177   if (I != MBB.end()) DL = I->getDebugLoc();
178   unsigned Opc = 0;
179 
180   if (RC == Mips::CPURegsRegisterClass)
181     Opc = IsN64 ? Mips::SW_P8 : Mips::SW;
182   else if (RC == Mips::CPU64RegsRegisterClass)
183     Opc = IsN64 ? Mips::SD_P8 : Mips::SD;
184   else if (RC == Mips::FGR32RegisterClass)
185     Opc = IsN64 ? Mips::SWC1_P8 : Mips::SWC1;
186   else if (RC == Mips::AFGR64RegisterClass)
187     Opc = Mips::SDC1;
188   else if (RC == Mips::FGR64RegisterClass)
189     Opc = IsN64 ? Mips::SDC164_P8 : Mips::SDC164;
190 
191   assert(Opc && "Register class not handled!");
192   BuildMI(MBB, I, DL, get(Opc)).addReg(SrcReg, getKillRegState(isKill))
193     .addFrameIndex(FI).addImm(0);
194 }
195 
196 void MipsInstrInfo::
197 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
198                      unsigned DestReg, int FI,
199                      const TargetRegisterClass *RC,
200                      const TargetRegisterInfo *TRI) const
201 {
202   DebugLoc DL;
203   if (I != MBB.end()) DL = I->getDebugLoc();
204   unsigned Opc = 0;
205 
206   if (RC == Mips::CPURegsRegisterClass)
207     Opc = IsN64 ? Mips::LW_P8 : Mips::LW;
208   else if (RC == Mips::CPU64RegsRegisterClass)
209     Opc = IsN64 ? Mips::LD_P8 : Mips::LD;
210   else if (RC == Mips::FGR32RegisterClass)
211     Opc = IsN64 ? Mips::LWC1_P8 : Mips::LWC1;
212   else if (RC == Mips::AFGR64RegisterClass)
213     Opc = Mips::LDC1;
214   else if (RC == Mips::FGR64RegisterClass)
215     Opc = IsN64 ? Mips::LDC164_P8 : Mips::LDC164;
216 
217   assert(Opc && "Register class not handled!");
218   BuildMI(MBB, I, DL, get(Opc), DestReg).addFrameIndex(FI).addImm(0);
219 }
220 
221 MachineInstr*
222 MipsInstrInfo::emitFrameIndexDebugValue(MachineFunction &MF, int FrameIx,
223                                         uint64_t Offset, const MDNode *MDPtr,
224                                         DebugLoc DL) const {
225   MachineInstrBuilder MIB = BuildMI(MF, DL, get(Mips::DBG_VALUE))
226     .addFrameIndex(FrameIx).addImm(0).addImm(Offset).addMetadata(MDPtr);
227   return &*MIB;
228 }
229 
230 //===----------------------------------------------------------------------===//
231 // Branch Analysis
232 //===----------------------------------------------------------------------===//
233 
234 static unsigned GetAnalyzableBrOpc(unsigned Opc) {
235   return (Opc == Mips::BEQ    || Opc == Mips::BNE    || Opc == Mips::BGTZ   ||
236           Opc == Mips::BGEZ   || Opc == Mips::BLTZ   || Opc == Mips::BLEZ   ||
237           Opc == Mips::BEQ64  || Opc == Mips::BNE64  || Opc == Mips::BGTZ64 ||
238           Opc == Mips::BGEZ64 || Opc == Mips::BLTZ64 || Opc == Mips::BLEZ64 ||
239           Opc == Mips::BC1T   || Opc == Mips::BC1F   || Opc == Mips::B      ||
240           Opc == Mips::J) ?
241          Opc : 0;
242 }
243 
244 /// GetOppositeBranchOpc - Return the inverse of the specified
245 /// opcode, e.g. turning BEQ to BNE.
246 unsigned Mips::GetOppositeBranchOpc(unsigned Opc)
247 {
248   switch (Opc) {
249   default:           llvm_unreachable("Illegal opcode!");
250   case Mips::BEQ:    return Mips::BNE;
251   case Mips::BNE:    return Mips::BEQ;
252   case Mips::BGTZ:   return Mips::BLEZ;
253   case Mips::BGEZ:   return Mips::BLTZ;
254   case Mips::BLTZ:   return Mips::BGEZ;
255   case Mips::BLEZ:   return Mips::BGTZ;
256   case Mips::BEQ64:  return Mips::BNE64;
257   case Mips::BNE64:  return Mips::BEQ64;
258   case Mips::BGTZ64: return Mips::BLEZ64;
259   case Mips::BGEZ64: return Mips::BLTZ64;
260   case Mips::BLTZ64: return Mips::BGEZ64;
261   case Mips::BLEZ64: return Mips::BGTZ64;
262   case Mips::BC1T:   return Mips::BC1F;
263   case Mips::BC1F:   return Mips::BC1T;
264   }
265 }
266 
267 static void AnalyzeCondBr(const MachineInstr* Inst, unsigned Opc,
268                           MachineBasicBlock *&BB,
269                           SmallVectorImpl<MachineOperand>& Cond) {
270   assert(GetAnalyzableBrOpc(Opc) && "Not an analyzable branch");
271   int NumOp = Inst->getNumExplicitOperands();
272 
273   // for both int and fp branches, the last explicit operand is the
274   // MBB.
275   BB = Inst->getOperand(NumOp-1).getMBB();
276   Cond.push_back(MachineOperand::CreateImm(Opc));
277 
278   for (int i=0; i<NumOp-1; i++)
279     Cond.push_back(Inst->getOperand(i));
280 }
281 
282 bool MipsInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,
283                                   MachineBasicBlock *&TBB,
284                                   MachineBasicBlock *&FBB,
285                                   SmallVectorImpl<MachineOperand> &Cond,
286                                   bool AllowModify) const
287 {
288   MachineBasicBlock::reverse_iterator I = MBB.rbegin(), REnd = MBB.rend();
289 
290   // Skip all the debug instructions.
291   while (I != REnd && I->isDebugValue())
292     ++I;
293 
294   if (I == REnd || !isUnpredicatedTerminator(&*I)) {
295     // If this block ends with no branches (it just falls through to its succ)
296     // just return false, leaving TBB/FBB null.
297     TBB = FBB = NULL;
298     return false;
299   }
300 
301   MachineInstr *LastInst = &*I;
302   unsigned LastOpc = LastInst->getOpcode();
303 
304   // Not an analyzable branch (must be an indirect jump).
305   if (!GetAnalyzableBrOpc(LastOpc))
306     return true;
307 
308   // Get the second to last instruction in the block.
309   unsigned SecondLastOpc = 0;
310   MachineInstr *SecondLastInst = NULL;
311 
312   if (++I != REnd) {
313     SecondLastInst = &*I;
314     SecondLastOpc = GetAnalyzableBrOpc(SecondLastInst->getOpcode());
315 
316     // Not an analyzable branch (must be an indirect jump).
317     if (isUnpredicatedTerminator(SecondLastInst) && !SecondLastOpc)
318       return true;
319   }
320 
321   // If there is only one terminator instruction, process it.
322   if (!SecondLastOpc) {
323     // Unconditional branch
324     if (LastOpc == UncondBrOpc) {
325       TBB = LastInst->getOperand(0).getMBB();
326       return false;
327     }
328 
329     // Conditional branch
330     AnalyzeCondBr(LastInst, LastOpc, TBB, Cond);
331     return false;
332   }
333 
334   // If we reached here, there are two branches.
335   // If there are three terminators, we don't know what sort of block this is.
336   if (++I != REnd && isUnpredicatedTerminator(&*I))
337     return true;
338 
339   // If second to last instruction is an unconditional branch,
340   // analyze it and remove the last instruction.
341   if (SecondLastOpc == UncondBrOpc) {
342     // Return if the last instruction cannot be removed.
343     if (!AllowModify)
344       return true;
345 
346     TBB = SecondLastInst->getOperand(0).getMBB();
347     LastInst->eraseFromParent();
348     return false;
349   }
350 
351   // Conditional branch followed by an unconditional branch.
352   // The last one must be unconditional.
353   if (LastOpc != UncondBrOpc)
354     return true;
355 
356   AnalyzeCondBr(SecondLastInst, SecondLastOpc, TBB, Cond);
357   FBB = LastInst->getOperand(0).getMBB();
358 
359   return false;
360 }
361 
362 void MipsInstrInfo::BuildCondBr(MachineBasicBlock &MBB,
363                                 MachineBasicBlock *TBB, DebugLoc DL,
364                                 const SmallVectorImpl<MachineOperand>& Cond)
365   const {
366   unsigned Opc = Cond[0].getImm();
367   const MCInstrDesc &MCID = get(Opc);
368   MachineInstrBuilder MIB = BuildMI(&MBB, DL, MCID);
369 
370   for (unsigned i = 1; i < Cond.size(); ++i)
371     MIB.addReg(Cond[i].getReg());
372 
373   MIB.addMBB(TBB);
374 }
375 
376 unsigned MipsInstrInfo::
377 InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
378              MachineBasicBlock *FBB,
379              const SmallVectorImpl<MachineOperand> &Cond,
380              DebugLoc DL) const {
381   // Shouldn't be a fall through.
382   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
383 
384   // # of condition operands:
385   //  Unconditional branches: 0
386   //  Floating point branches: 1 (opc)
387   //  Int BranchZero: 2 (opc, reg)
388   //  Int Branch: 3 (opc, reg0, reg1)
389   assert((Cond.size() <= 3) &&
390          "# of Mips branch conditions must be <= 3!");
391 
392   // Two-way Conditional branch.
393   if (FBB) {
394     BuildCondBr(MBB, TBB, DL, Cond);
395     BuildMI(&MBB, DL, get(UncondBrOpc)).addMBB(FBB);
396     return 2;
397   }
398 
399   // One way branch.
400   // Unconditional branch.
401   if (Cond.empty())
402     BuildMI(&MBB, DL, get(UncondBrOpc)).addMBB(TBB);
403   else // Conditional branch.
404     BuildCondBr(MBB, TBB, DL, Cond);
405   return 1;
406 }
407 
408 unsigned MipsInstrInfo::
409 RemoveBranch(MachineBasicBlock &MBB) const
410 {
411   MachineBasicBlock::reverse_iterator I = MBB.rbegin(), REnd = MBB.rend();
412   MachineBasicBlock::reverse_iterator FirstBr;
413   unsigned removed;
414 
415   // Skip all the debug instructions.
416   while (I != REnd && I->isDebugValue())
417     ++I;
418 
419   FirstBr = I;
420 
421   // Up to 2 branches are removed.
422   // Note that indirect branches are not removed.
423   for(removed = 0; I != REnd && removed < 2; ++I, ++removed)
424     if (!GetAnalyzableBrOpc(I->getOpcode()))
425       break;
426 
427   MBB.erase(I.base(), FirstBr.base());
428 
429   return removed;
430 }
431 
432 /// ReverseBranchCondition - Return the inverse opcode of the
433 /// specified Branch instruction.
434 bool MipsInstrInfo::
435 ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const
436 {
437   assert( (Cond.size() && Cond.size() <= 3) &&
438           "Invalid Mips branch condition!");
439   Cond[0].setImm(Mips::GetOppositeBranchOpc(Cond[0].getImm()));
440   return false;
441 }
442 
443 /// getGlobalBaseReg - Return a virtual register initialized with the
444 /// the global base register value. Output instructions required to
445 /// initialize the register in the function entry block, if necessary.
446 ///
447 unsigned MipsInstrInfo::getGlobalBaseReg(MachineFunction *MF) const {
448   MipsFunctionInfo *MipsFI = MF->getInfo<MipsFunctionInfo>();
449   unsigned GlobalBaseReg = MipsFI->getGlobalBaseReg();
450   if (GlobalBaseReg != 0)
451     return GlobalBaseReg;
452 
453   // Insert the set of GlobalBaseReg into the first MBB of the function
454   MachineBasicBlock &FirstMBB = MF->front();
455   MachineBasicBlock::iterator MBBI = FirstMBB.begin();
456   MachineRegisterInfo &RegInfo = MF->getRegInfo();
457   const TargetInstrInfo *TII = MF->getTarget().getInstrInfo();
458 
459   GlobalBaseReg = RegInfo.createVirtualRegister(Mips::CPURegsRegisterClass);
460   BuildMI(FirstMBB, MBBI, DebugLoc(), TII->get(TargetOpcode::COPY),
461           GlobalBaseReg).addReg(Mips::GP);
462   RegInfo.addLiveIn(Mips::GP);
463 
464   MipsFI->setGlobalBaseReg(GlobalBaseReg);
465   return GlobalBaseReg;
466 }
467