1 //===- AlphaInstrInfo.cpp - Alpha Instruction Information -------*- C++ -*-===//
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 contains the Alpha implementation of the TargetInstrInfo class.
12 //===----------------------------------------------------------------------===//
15 #include "AlphaInstrInfo.h"
16 #include "AlphaMachineFunctionInfo.h"
17 #include "llvm/CodeGen/MachineInstrBuilder.h"
18 #include "llvm/CodeGen/MachineRegisterInfo.h"
19 #include "llvm/Target/TargetRegistry.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/Support/ErrorHandling.h"
24 #define GET_INSTRINFO_MC_DESC
25 #define GET_INSTRINFO_CTOR
26 #include "AlphaGenInstrInfo.inc"
29 AlphaInstrInfo::AlphaInstrInfo()
30 : AlphaGenInstrInfo(Alpha::ADJUSTSTACKDOWN, Alpha::ADJUSTSTACKUP),
36 AlphaInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
37 int &FrameIndex) const {
38 switch (MI->getOpcode()) {
45 if (MI->getOperand(1).isFI()) {
46 FrameIndex = MI->getOperand(1).getIndex();
47 return MI->getOperand(0).getReg();
55 AlphaInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
56 int &FrameIndex) const {
57 switch (MI->getOpcode()) {
64 if (MI->getOperand(1).isFI()) {
65 FrameIndex = MI->getOperand(1).getIndex();
66 return MI->getOperand(0).getReg();
73 static bool isAlphaIntCondCode(unsigned Opcode) {
89 unsigned AlphaInstrInfo::InsertBranch(MachineBasicBlock &MBB,
90 MachineBasicBlock *TBB,
91 MachineBasicBlock *FBB,
92 const SmallVectorImpl<MachineOperand> &Cond,
94 assert(TBB && "InsertBranch must not be told to insert a fallthrough");
95 assert((Cond.size() == 2 || Cond.size() == 0) &&
96 "Alpha branch conditions have two components!");
100 if (Cond.empty()) // Unconditional branch
101 BuildMI(&MBB, DL, get(Alpha::BR)).addMBB(TBB);
102 else // Conditional branch
103 if (isAlphaIntCondCode(Cond[0].getImm()))
104 BuildMI(&MBB, DL, get(Alpha::COND_BRANCH_I))
105 .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
107 BuildMI(&MBB, DL, get(Alpha::COND_BRANCH_F))
108 .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
112 // Two-way Conditional Branch.
113 if (isAlphaIntCondCode(Cond[0].getImm()))
114 BuildMI(&MBB, DL, get(Alpha::COND_BRANCH_I))
115 .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
117 BuildMI(&MBB, DL, get(Alpha::COND_BRANCH_F))
118 .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
119 BuildMI(&MBB, DL, get(Alpha::BR)).addMBB(FBB);
123 void AlphaInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
124 MachineBasicBlock::iterator MI, DebugLoc DL,
125 unsigned DestReg, unsigned SrcReg,
126 bool KillSrc) const {
127 if (Alpha::GPRCRegClass.contains(DestReg, SrcReg)) {
128 BuildMI(MBB, MI, DL, get(Alpha::BISr), DestReg)
130 .addReg(SrcReg, getKillRegState(KillSrc));
131 } else if (Alpha::F4RCRegClass.contains(DestReg, SrcReg)) {
132 BuildMI(MBB, MI, DL, get(Alpha::CPYSS), DestReg)
134 .addReg(SrcReg, getKillRegState(KillSrc));
135 } else if (Alpha::F8RCRegClass.contains(DestReg, SrcReg)) {
136 BuildMI(MBB, MI, DL, get(Alpha::CPYST), DestReg)
138 .addReg(SrcReg, getKillRegState(KillSrc));
140 llvm_unreachable("Attempt to copy register that is not GPR or FPR");
145 AlphaInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
146 MachineBasicBlock::iterator MI,
147 unsigned SrcReg, bool isKill, int FrameIdx,
148 const TargetRegisterClass *RC,
149 const TargetRegisterInfo *TRI) const {
150 //cerr << "Trying to store " << getPrettyName(SrcReg) << " to "
151 // << FrameIdx << "\n";
152 //BuildMI(MBB, MI, Alpha::WTF, 0).addReg(SrcReg);
155 if (MI != MBB.end()) DL = MI->getDebugLoc();
157 if (RC == Alpha::F4RCRegisterClass)
158 BuildMI(MBB, MI, DL, get(Alpha::STS))
159 .addReg(SrcReg, getKillRegState(isKill))
160 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
161 else if (RC == Alpha::F8RCRegisterClass)
162 BuildMI(MBB, MI, DL, get(Alpha::STT))
163 .addReg(SrcReg, getKillRegState(isKill))
164 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
165 else if (RC == Alpha::GPRCRegisterClass)
166 BuildMI(MBB, MI, DL, get(Alpha::STQ))
167 .addReg(SrcReg, getKillRegState(isKill))
168 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
170 llvm_unreachable("Unhandled register class");
174 AlphaInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
175 MachineBasicBlock::iterator MI,
176 unsigned DestReg, int FrameIdx,
177 const TargetRegisterClass *RC,
178 const TargetRegisterInfo *TRI) const {
179 //cerr << "Trying to load " << getPrettyName(DestReg) << " to "
180 // << FrameIdx << "\n";
182 if (MI != MBB.end()) DL = MI->getDebugLoc();
184 if (RC == Alpha::F4RCRegisterClass)
185 BuildMI(MBB, MI, DL, get(Alpha::LDS), DestReg)
186 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
187 else if (RC == Alpha::F8RCRegisterClass)
188 BuildMI(MBB, MI, DL, get(Alpha::LDT), DestReg)
189 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
190 else if (RC == Alpha::GPRCRegisterClass)
191 BuildMI(MBB, MI, DL, get(Alpha::LDQ), DestReg)
192 .addFrameIndex(FrameIdx).addReg(Alpha::F31);
194 llvm_unreachable("Unhandled register class");
197 static unsigned AlphaRevCondCode(unsigned Opcode) {
199 case Alpha::BEQ: return Alpha::BNE;
200 case Alpha::BNE: return Alpha::BEQ;
201 case Alpha::BGE: return Alpha::BLT;
202 case Alpha::BGT: return Alpha::BLE;
203 case Alpha::BLE: return Alpha::BGT;
204 case Alpha::BLT: return Alpha::BGE;
205 case Alpha::BLBC: return Alpha::BLBS;
206 case Alpha::BLBS: return Alpha::BLBC;
207 case Alpha::FBEQ: return Alpha::FBNE;
208 case Alpha::FBNE: return Alpha::FBEQ;
209 case Alpha::FBGE: return Alpha::FBLT;
210 case Alpha::FBGT: return Alpha::FBLE;
211 case Alpha::FBLE: return Alpha::FBGT;
212 case Alpha::FBLT: return Alpha::FBGE;
214 llvm_unreachable("Unknown opcode");
216 return 0; // Not reached
220 bool AlphaInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
221 MachineBasicBlock *&FBB,
222 SmallVectorImpl<MachineOperand> &Cond,
223 bool AllowModify) const {
224 // If the block has no terminators, it just falls into the block after it.
225 MachineBasicBlock::iterator I = MBB.end();
226 if (I == MBB.begin())
229 while (I->isDebugValue()) {
230 if (I == MBB.begin())
234 if (!isUnpredicatedTerminator(I))
237 // Get the last instruction in the block.
238 MachineInstr *LastInst = I;
240 // If there is only one terminator instruction, process it.
241 if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
242 if (LastInst->getOpcode() == Alpha::BR) {
243 TBB = LastInst->getOperand(0).getMBB();
245 } else if (LastInst->getOpcode() == Alpha::COND_BRANCH_I ||
246 LastInst->getOpcode() == Alpha::COND_BRANCH_F) {
247 // Block ends with fall-through condbranch.
248 TBB = LastInst->getOperand(2).getMBB();
249 Cond.push_back(LastInst->getOperand(0));
250 Cond.push_back(LastInst->getOperand(1));
253 // Otherwise, don't know what this is.
257 // Get the instruction before it if it's a terminator.
258 MachineInstr *SecondLastInst = I;
260 // If there are three terminators, we don't know what sort of block this is.
261 if (SecondLastInst && I != MBB.begin() &&
262 isUnpredicatedTerminator(--I))
265 // If the block ends with Alpha::BR and Alpha::COND_BRANCH_*, handle it.
266 if ((SecondLastInst->getOpcode() == Alpha::COND_BRANCH_I ||
267 SecondLastInst->getOpcode() == Alpha::COND_BRANCH_F) &&
268 LastInst->getOpcode() == Alpha::BR) {
269 TBB = SecondLastInst->getOperand(2).getMBB();
270 Cond.push_back(SecondLastInst->getOperand(0));
271 Cond.push_back(SecondLastInst->getOperand(1));
272 FBB = LastInst->getOperand(0).getMBB();
276 // If the block ends with two Alpha::BRs, handle it. The second one is not
277 // executed, so remove it.
278 if (SecondLastInst->getOpcode() == Alpha::BR &&
279 LastInst->getOpcode() == Alpha::BR) {
280 TBB = SecondLastInst->getOperand(0).getMBB();
283 I->eraseFromParent();
287 // Otherwise, can't handle this.
291 unsigned AlphaInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
292 MachineBasicBlock::iterator I = MBB.end();
293 if (I == MBB.begin()) return 0;
295 while (I->isDebugValue()) {
296 if (I == MBB.begin())
300 if (I->getOpcode() != Alpha::BR &&
301 I->getOpcode() != Alpha::COND_BRANCH_I &&
302 I->getOpcode() != Alpha::COND_BRANCH_F)
305 // Remove the branch.
306 I->eraseFromParent();
310 if (I == MBB.begin()) return 1;
312 if (I->getOpcode() != Alpha::COND_BRANCH_I &&
313 I->getOpcode() != Alpha::COND_BRANCH_F)
316 // Remove the branch.
317 I->eraseFromParent();
321 void AlphaInstrInfo::insertNoop(MachineBasicBlock &MBB,
322 MachineBasicBlock::iterator MI) const {
324 BuildMI(MBB, MI, DL, get(Alpha::BISr), Alpha::R31)
329 bool AlphaInstrInfo::
330 ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
331 assert(Cond.size() == 2 && "Invalid Alpha branch opcode!");
332 Cond[0].setImm(AlphaRevCondCode(Cond[0].getImm()));
336 /// getGlobalBaseReg - Return a virtual register initialized with the
337 /// the global base register value. Output instructions required to
338 /// initialize the register in the function entry block, if necessary.
340 unsigned AlphaInstrInfo::getGlobalBaseReg(MachineFunction *MF) const {
341 AlphaMachineFunctionInfo *AlphaFI = MF->getInfo<AlphaMachineFunctionInfo>();
342 unsigned GlobalBaseReg = AlphaFI->getGlobalBaseReg();
343 if (GlobalBaseReg != 0)
344 return GlobalBaseReg;
346 // Insert the set of GlobalBaseReg into the first MBB of the function
347 MachineBasicBlock &FirstMBB = MF->front();
348 MachineBasicBlock::iterator MBBI = FirstMBB.begin();
349 MachineRegisterInfo &RegInfo = MF->getRegInfo();
350 const TargetInstrInfo *TII = MF->getTarget().getInstrInfo();
352 GlobalBaseReg = RegInfo.createVirtualRegister(&Alpha::GPRCRegClass);
353 BuildMI(FirstMBB, MBBI, DebugLoc(), TII->get(TargetOpcode::COPY),
354 GlobalBaseReg).addReg(Alpha::R29);
355 RegInfo.addLiveIn(Alpha::R29);
357 AlphaFI->setGlobalBaseReg(GlobalBaseReg);
358 return GlobalBaseReg;
361 /// getGlobalRetAddr - Return a virtual register initialized with the
362 /// the global base register value. Output instructions required to
363 /// initialize the register in the function entry block, if necessary.
365 unsigned AlphaInstrInfo::getGlobalRetAddr(MachineFunction *MF) const {
366 AlphaMachineFunctionInfo *AlphaFI = MF->getInfo<AlphaMachineFunctionInfo>();
367 unsigned GlobalRetAddr = AlphaFI->getGlobalRetAddr();
368 if (GlobalRetAddr != 0)
369 return GlobalRetAddr;
371 // Insert the set of GlobalRetAddr into the first MBB of the function
372 MachineBasicBlock &FirstMBB = MF->front();
373 MachineBasicBlock::iterator MBBI = FirstMBB.begin();
374 MachineRegisterInfo &RegInfo = MF->getRegInfo();
375 const TargetInstrInfo *TII = MF->getTarget().getInstrInfo();
377 GlobalRetAddr = RegInfo.createVirtualRegister(&Alpha::GPRCRegClass);
378 BuildMI(FirstMBB, MBBI, DebugLoc(), TII->get(TargetOpcode::COPY),
379 GlobalRetAddr).addReg(Alpha::R26);
380 RegInfo.addLiveIn(Alpha::R26);
382 AlphaFI->setGlobalRetAddr(GlobalRetAddr);
383 return GlobalRetAddr;
386 MCInstrInfo *createAlphaMCInstrInfo() {
387 MCInstrInfo *X = new MCInstrInfo();
388 InitAlphaMCInstrInfo(X);
392 extern "C" void LLVMInitializeAlphaMCInstrInfo() {
393 TargetRegistry::RegisterMCInstrInfo(TheAlphaTarget, createAlphaMCInstrInfo);