remove all but one reference to TargetRegisterDesc::AsmName.
[llvm/avr.git] / lib / Target / MSP430 / MSP430InstrInfo.cpp
blob37fbb6d9999bc31e95a862ff235c055830da3ddf
1 //===- MSP430InstrInfo.cpp - MSP430 Instruction Information ---------------===//
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 MSP430 implementation of the TargetInstrInfo class.
12 //===----------------------------------------------------------------------===//
14 #include "MSP430.h"
15 #include "MSP430InstrInfo.h"
16 #include "MSP430MachineFunctionInfo.h"
17 #include "MSP430TargetMachine.h"
18 #include "MSP430GenInstrInfo.inc"
19 #include "llvm/Function.h"
20 #include "llvm/CodeGen/MachineFrameInfo.h"
21 #include "llvm/CodeGen/MachineInstrBuilder.h"
22 #include "llvm/CodeGen/MachineRegisterInfo.h"
23 #include "llvm/CodeGen/PseudoSourceValue.h"
24 #include "llvm/Support/ErrorHandling.h"
26 using namespace llvm;
28 MSP430InstrInfo::MSP430InstrInfo(MSP430TargetMachine &tm)
29 : TargetInstrInfoImpl(MSP430Insts, array_lengthof(MSP430Insts)),
30 RI(tm, *this), TM(tm) {}
32 void MSP430InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
33 MachineBasicBlock::iterator MI,
34 unsigned SrcReg, bool isKill, int FrameIdx,
35 const TargetRegisterClass *RC) const {
36 DebugLoc DL = DebugLoc::getUnknownLoc();
37 if (MI != MBB.end()) DL = MI->getDebugLoc();
39 if (RC == &MSP430::GR16RegClass)
40 BuildMI(MBB, MI, DL, get(MSP430::MOV16mr))
41 .addFrameIndex(FrameIdx).addImm(0)
42 .addReg(SrcReg, getKillRegState(isKill));
43 else if (RC == &MSP430::GR8RegClass)
44 BuildMI(MBB, MI, DL, get(MSP430::MOV8mr))
45 .addFrameIndex(FrameIdx).addImm(0)
46 .addReg(SrcReg, getKillRegState(isKill));
47 else
48 llvm_unreachable("Cannot store this register to stack slot!");
51 void MSP430InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
52 MachineBasicBlock::iterator MI,
53 unsigned DestReg, int FrameIdx,
54 const TargetRegisterClass *RC) const{
55 DebugLoc DL = DebugLoc::getUnknownLoc();
56 if (MI != MBB.end()) DL = MI->getDebugLoc();
58 if (RC == &MSP430::GR16RegClass)
59 BuildMI(MBB, MI, DL, get(MSP430::MOV16rm))
60 .addReg(DestReg).addFrameIndex(FrameIdx).addImm(0);
61 else if (RC == &MSP430::GR8RegClass)
62 BuildMI(MBB, MI, DL, get(MSP430::MOV8rm))
63 .addReg(DestReg).addFrameIndex(FrameIdx).addImm(0);
64 else
65 llvm_unreachable("Cannot store this register to stack slot!");
68 bool MSP430InstrInfo::copyRegToReg(MachineBasicBlock &MBB,
69 MachineBasicBlock::iterator I,
70 unsigned DestReg, unsigned SrcReg,
71 const TargetRegisterClass *DestRC,
72 const TargetRegisterClass *SrcRC) const {
73 DebugLoc DL = DebugLoc::getUnknownLoc();
74 if (I != MBB.end()) DL = I->getDebugLoc();
76 if (DestRC == SrcRC) {
77 unsigned Opc;
78 if (DestRC == &MSP430::GR16RegClass) {
79 Opc = MSP430::MOV16rr;
80 } else if (DestRC == &MSP430::GR8RegClass) {
81 Opc = MSP430::MOV8rr;
82 } else {
83 return false;
86 BuildMI(MBB, I, DL, get(Opc), DestReg).addReg(SrcReg);
87 return true;
90 return false;
93 bool
94 MSP430InstrInfo::isMoveInstr(const MachineInstr& MI,
95 unsigned &SrcReg, unsigned &DstReg,
96 unsigned &SrcSubIdx, unsigned &DstSubIdx) const {
97 SrcSubIdx = DstSubIdx = 0; // No sub-registers yet.
99 switch (MI.getOpcode()) {
100 default:
101 return false;
102 case MSP430::MOV8rr:
103 case MSP430::MOV16rr:
104 assert(MI.getNumOperands() >= 2 &&
105 MI.getOperand(0).isReg() &&
106 MI.getOperand(1).isReg() &&
107 "invalid register-register move instruction");
108 SrcReg = MI.getOperand(1).getReg();
109 DstReg = MI.getOperand(0).getReg();
110 return true;
114 bool
115 MSP430InstrInfo::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
116 MachineBasicBlock::iterator MI,
117 const std::vector<CalleeSavedInfo> &CSI) const {
118 if (CSI.empty())
119 return false;
121 DebugLoc DL = DebugLoc::getUnknownLoc();
122 if (MI != MBB.end()) DL = MI->getDebugLoc();
124 MachineFunction &MF = *MBB.getParent();
125 MSP430MachineFunctionInfo *MFI = MF.getInfo<MSP430MachineFunctionInfo>();
126 MFI->setCalleeSavedFrameSize(CSI.size() * 2);
128 for (unsigned i = CSI.size(); i != 0; --i) {
129 unsigned Reg = CSI[i-1].getReg();
130 // Add the callee-saved register as live-in. It's killed at the spill.
131 MBB.addLiveIn(Reg);
132 BuildMI(MBB, MI, DL, get(MSP430::PUSH16r))
133 .addReg(Reg, RegState::Kill);
135 return true;
138 bool
139 MSP430InstrInfo::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
140 MachineBasicBlock::iterator MI,
141 const std::vector<CalleeSavedInfo> &CSI) const {
142 if (CSI.empty())
143 return false;
145 DebugLoc DL = DebugLoc::getUnknownLoc();
146 if (MI != MBB.end()) DL = MI->getDebugLoc();
148 for (unsigned i = 0, e = CSI.size(); i != e; ++i)
149 BuildMI(MBB, MI, DL, get(MSP430::POP16r), CSI[i].getReg());
151 return true;
154 unsigned
155 MSP430InstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
156 MachineBasicBlock *FBB,
157 const SmallVectorImpl<MachineOperand> &Cond) const {
158 // FIXME this should probably have a DebugLoc operand
159 DebugLoc dl = DebugLoc::getUnknownLoc();
161 // Shouldn't be a fall through.
162 assert(TBB && "InsertBranch must not be told to insert a fallthrough");
163 assert((Cond.size() == 1 || Cond.size() == 0) &&
164 "MSP430 branch conditions have one component!");
166 if (Cond.empty()) {
167 // Unconditional branch?
168 assert(!FBB && "Unconditional branch with multiple successors!");
169 BuildMI(&MBB, dl, get(MSP430::JMP)).addMBB(TBB);
170 return 1;
173 // Conditional branch.
174 unsigned Count = 0;
175 llvm_unreachable("Implement conditional branches!");
177 return Count;