1 //===-- MSP430InstrInfo.cpp - MSP430 Instruction Information --------------===//
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 file contains the MSP430 implementation of the TargetInstrInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "MSP430InstrInfo.h"
14 #include "MSP430.h"
15 #include "MSP430MachineFunctionInfo.h"
16 #include "MSP430TargetMachine.h"
17 #include "llvm/CodeGen/MachineFrameInfo.h"
18 #include "llvm/CodeGen/MachineInstrBuilder.h"
19 #include "llvm/CodeGen/MachineRegisterInfo.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/TargetRegistry.h"
23 
24 using namespace llvm;
25 
26 #define GET_INSTRINFO_CTOR_DTOR
27 #include "MSP430GenInstrInfo.inc"
28 
29 // Pin the vtable to this file.
30 void MSP430InstrInfo::anchor() {}
31 
32 MSP430InstrInfo::MSP430InstrInfo(MSP430Subtarget &STI)
33   : MSP430GenInstrInfo(MSP430::ADJCALLSTACKDOWN, MSP430::ADJCALLSTACKUP),
34     RI() {}
35 
36 void MSP430InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
37                                           MachineBasicBlock::iterator MI,
38                                     Register SrcReg, bool isKill, int FrameIdx,
39                                           const TargetRegisterClass *RC,
40                                           const TargetRegisterInfo *TRI) const {
41   DebugLoc DL;
42   if (MI != MBB.end()) DL = MI->getDebugLoc();
43   MachineFunction &MF = *MBB.getParent();
44   MachineFrameInfo &MFI = MF.getFrameInfo();
45 
46   MachineMemOperand *MMO = MF.getMachineMemOperand(
47       MachinePointerInfo::getFixedStack(MF, FrameIdx),
48       MachineMemOperand::MOStore, MFI.getObjectSize(FrameIdx),
49       MFI.getObjectAlign(FrameIdx));
50 
51   if (RC == &MSP430::GR16RegClass)
52     BuildMI(MBB, MI, DL, get(MSP430::MOV16mr))
53       .addFrameIndex(FrameIdx).addImm(0)
54       .addReg(SrcReg, getKillRegState(isKill)).addMemOperand(MMO);
55   else if (RC == &MSP430::GR8RegClass)
56     BuildMI(MBB, MI, DL, get(MSP430::MOV8mr))
57       .addFrameIndex(FrameIdx).addImm(0)
58       .addReg(SrcReg, getKillRegState(isKill)).addMemOperand(MMO);
59   else
60     llvm_unreachable("Cannot store this register to stack slot!");
61 }
62 
63 void MSP430InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
64                                            MachineBasicBlock::iterator MI,
65                                            Register DestReg, int FrameIdx,
66                                            const TargetRegisterClass *RC,
67                                            const TargetRegisterInfo *TRI) const{
68   DebugLoc DL;
69   if (MI != MBB.end()) DL = MI->getDebugLoc();
70   MachineFunction &MF = *MBB.getParent();
71   MachineFrameInfo &MFI = MF.getFrameInfo();
72 
73   MachineMemOperand *MMO = MF.getMachineMemOperand(
74       MachinePointerInfo::getFixedStack(MF, FrameIdx),
75       MachineMemOperand::MOLoad, MFI.getObjectSize(FrameIdx),
76       MFI.getObjectAlign(FrameIdx));
77 
78   if (RC == &MSP430::GR16RegClass)
79     BuildMI(MBB, MI, DL, get(MSP430::MOV16rm))
80       .addReg(DestReg, getDefRegState(true)).addFrameIndex(FrameIdx)
81       .addImm(0).addMemOperand(MMO);
82   else if (RC == &MSP430::GR8RegClass)
83     BuildMI(MBB, MI, DL, get(MSP430::MOV8rm))
84       .addReg(DestReg, getDefRegState(true)).addFrameIndex(FrameIdx)
85       .addImm(0).addMemOperand(MMO);
86   else
87     llvm_unreachable("Cannot store this register to stack slot!");
88 }
89 
90 void MSP430InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
91                                   MachineBasicBlock::iterator I,
92                                   const DebugLoc &DL, MCRegister DestReg,
93                                   MCRegister SrcReg, bool KillSrc) const {
94   unsigned Opc;
95   if (MSP430::GR16RegClass.contains(DestReg, SrcReg))
96     Opc = MSP430::MOV16rr;
97   else if (MSP430::GR8RegClass.contains(DestReg, SrcReg))
98     Opc = MSP430::MOV8rr;
99   else
100     llvm_unreachable("Impossible reg-to-reg copy");
101 
102   BuildMI(MBB, I, DL, get(Opc), DestReg)
103     .addReg(SrcReg, getKillRegState(KillSrc));
104 }
105 
106 unsigned MSP430InstrInfo::removeBranch(MachineBasicBlock &MBB,
107                                        int *BytesRemoved) const {
108   assert(!BytesRemoved && "code size not handled");
109 
110   MachineBasicBlock::iterator I = MBB.end();
111   unsigned Count = 0;
112 
113   while (I != MBB.begin()) {
114     --I;
115     if (I->isDebugInstr())
116       continue;
117     if (I->getOpcode() != MSP430::JMP &&
118         I->getOpcode() != MSP430::JCC &&
119         I->getOpcode() != MSP430::Br &&
120         I->getOpcode() != MSP430::Bm)
121       break;
122     // Remove the branch.
123     I->eraseFromParent();
124     I = MBB.end();
125     ++Count;
126   }
127 
128   return Count;
129 }
130 
131 bool MSP430InstrInfo::
132 reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
133   assert(Cond.size() == 1 && "Invalid Xbranch condition!");
134 
135   MSP430CC::CondCodes CC = static_cast<MSP430CC::CondCodes>(Cond[0].getImm());
136 
137   switch (CC) {
138   default: llvm_unreachable("Invalid branch condition!");
139   case MSP430CC::COND_E:
140     CC = MSP430CC::COND_NE;
141     break;
142   case MSP430CC::COND_NE:
143     CC = MSP430CC::COND_E;
144     break;
145   case MSP430CC::COND_L:
146     CC = MSP430CC::COND_GE;
147     break;
148   case MSP430CC::COND_GE:
149     CC = MSP430CC::COND_L;
150     break;
151   case MSP430CC::COND_HS:
152     CC = MSP430CC::COND_LO;
153     break;
154   case MSP430CC::COND_LO:
155     CC = MSP430CC::COND_HS;
156     break;
157   }
158 
159   Cond[0].setImm(CC);
160   return false;
161 }
162 
163 bool MSP430InstrInfo::analyzeBranch(MachineBasicBlock &MBB,
164                                     MachineBasicBlock *&TBB,
165                                     MachineBasicBlock *&FBB,
166                                     SmallVectorImpl<MachineOperand> &Cond,
167                                     bool AllowModify) const {
168   // Start from the bottom of the block and work up, examining the
169   // terminator instructions.
170   MachineBasicBlock::iterator I = MBB.end();
171   while (I != MBB.begin()) {
172     --I;
173     if (I->isDebugInstr())
174       continue;
175 
176     // Working from the bottom, when we see a non-terminator
177     // instruction, we're done.
178     if (!isUnpredicatedTerminator(*I))
179       break;
180 
181     // A terminator that isn't a branch can't easily be handled
182     // by this analysis.
183     if (!I->isBranch())
184       return true;
185 
186     // Cannot handle indirect branches.
187     if (I->getOpcode() == MSP430::Br ||
188         I->getOpcode() == MSP430::Bm)
189       return true;
190 
191     // Handle unconditional branches.
192     if (I->getOpcode() == MSP430::JMP) {
193       if (!AllowModify) {
194         TBB = I->getOperand(0).getMBB();
195         continue;
196       }
197 
198       // If the block has any instructions after a JMP, delete them.
199       while (std::next(I) != MBB.end())
200         std::next(I)->eraseFromParent();
201       Cond.clear();
202       FBB = nullptr;
203 
204       // Delete the JMP if it's equivalent to a fall-through.
205       if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) {
206         TBB = nullptr;
207         I->eraseFromParent();
208         I = MBB.end();
209         continue;
210       }
211 
212       // TBB is used to indicate the unconditinal destination.
213       TBB = I->getOperand(0).getMBB();
214       continue;
215     }
216 
217     // Handle conditional branches.
218     assert(I->getOpcode() == MSP430::JCC && "Invalid conditional branch");
219     MSP430CC::CondCodes BranchCode =
220       static_cast<MSP430CC::CondCodes>(I->getOperand(1).getImm());
221     if (BranchCode == MSP430CC::COND_INVALID)
222       return true;  // Can't handle weird stuff.
223 
224     // Working from the bottom, handle the first conditional branch.
225     if (Cond.empty()) {
226       FBB = TBB;
227       TBB = I->getOperand(0).getMBB();
228       Cond.push_back(MachineOperand::CreateImm(BranchCode));
229       continue;
230     }
231 
232     // Handle subsequent conditional branches. Only handle the case where all
233     // conditional branches branch to the same destination.
234     assert(Cond.size() == 1);
235     assert(TBB);
236 
237     // Only handle the case where all conditional branches branch to
238     // the same destination.
239     if (TBB != I->getOperand(0).getMBB())
240       return true;
241 
242     MSP430CC::CondCodes OldBranchCode = (MSP430CC::CondCodes)Cond[0].getImm();
243     // If the conditions are the same, we can leave them alone.
244     if (OldBranchCode == BranchCode)
245       continue;
246 
247     return true;
248   }
249 
250   return false;
251 }
252 
253 unsigned MSP430InstrInfo::insertBranch(MachineBasicBlock &MBB,
254                                        MachineBasicBlock *TBB,
255                                        MachineBasicBlock *FBB,
256                                        ArrayRef<MachineOperand> Cond,
257                                        const DebugLoc &DL,
258                                        int *BytesAdded) const {
259   // Shouldn't be a fall through.
260   assert(TBB && "insertBranch must not be told to insert a fallthrough");
261   assert((Cond.size() == 1 || Cond.size() == 0) &&
262          "MSP430 branch conditions have one component!");
263   assert(!BytesAdded && "code size not handled");
264 
265   if (Cond.empty()) {
266     // Unconditional branch?
267     assert(!FBB && "Unconditional branch with multiple successors!");
268     BuildMI(&MBB, DL, get(MSP430::JMP)).addMBB(TBB);
269     return 1;
270   }
271 
272   // Conditional branch.
273   unsigned Count = 0;
274   BuildMI(&MBB, DL, get(MSP430::JCC)).addMBB(TBB).addImm(Cond[0].getImm());
275   ++Count;
276 
277   if (FBB) {
278     // Two-way Conditional branch. Insert the second branch.
279     BuildMI(&MBB, DL, get(MSP430::JMP)).addMBB(FBB);
280     ++Count;
281   }
282   return Count;
283 }
284 
285 /// GetInstSize - Return the number of bytes of code the specified
286 /// instruction may be.  This returns the maximum number of bytes.
287 ///
288 unsigned MSP430InstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
289   const MCInstrDesc &Desc = MI.getDesc();
290 
291   switch (Desc.getOpcode()) {
292   case TargetOpcode::CFI_INSTRUCTION:
293   case TargetOpcode::EH_LABEL:
294   case TargetOpcode::IMPLICIT_DEF:
295   case TargetOpcode::KILL:
296   case TargetOpcode::DBG_VALUE:
297     return 0;
298   case TargetOpcode::INLINEASM:
299   case TargetOpcode::INLINEASM_BR: {
300     const MachineFunction *MF = MI.getParent()->getParent();
301     const TargetInstrInfo &TII = *MF->getSubtarget().getInstrInfo();
302     return TII.getInlineAsmLength(MI.getOperand(0).getSymbolName(),
303                                   *MF->getTarget().getMCAsmInfo());
304   }
305   }
306 
307   return Desc.getSize();
308 }
309