1 //===- PTXInstrInfo.cpp - PTX Instruction Information ---------------------===//
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 PTX implementation of the TargetInstrInfo class.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "ptx-instrinfo"
17 #include "PTXInstrInfo.h"
18 #include "llvm/CodeGen/MachineInstrBuilder.h"
19 #include "llvm/CodeGen/SelectionDAG.h"
20 #include "llvm/CodeGen/SelectionDAGNodes.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/raw_ostream.h"
26 #include "PTXGenInstrInfo.inc"
28 PTXInstrInfo::PTXInstrInfo(PTXTargetMachine &_TM)
29 : TargetInstrInfoImpl(PTXInsts, array_lengthof(PTXInsts)),
30 RI(_TM, *this), TM(_TM) {}
32 static const struct map_entry {
33 const TargetRegisterClass *cls;
36 { &PTX::RRegu16RegClass, PTX::MOVU16rr },
37 { &PTX::RRegu32RegClass, PTX::MOVU32rr },
38 { &PTX::RRegu64RegClass, PTX::MOVU64rr },
39 { &PTX::RRegf32RegClass, PTX::MOVF32rr },
40 { &PTX::RRegf64RegClass, PTX::MOVF64rr },
41 { &PTX::PredsRegClass, PTX::MOVPREDrr }
44 void PTXInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
45 MachineBasicBlock::iterator I, DebugLoc DL,
46 unsigned DstReg, unsigned SrcReg,
48 for (int i = 0, e = sizeof(map)/sizeof(map[0]); i != e; ++ i) {
49 if (map[i].cls->contains(DstReg, SrcReg)) {
50 const TargetInstrDesc &TID = get(map[i].opcode);
51 MachineInstr *MI = BuildMI(MBB, I, DL, TID, DstReg).
52 addReg(SrcReg, getKillRegState(KillSrc));
53 AddDefaultPredicate(MI);
58 llvm_unreachable("Impossible reg-to-reg copy");
61 bool PTXInstrInfo::copyRegToReg(MachineBasicBlock &MBB,
62 MachineBasicBlock::iterator I,
63 unsigned DstReg, unsigned SrcReg,
64 const TargetRegisterClass *DstRC,
65 const TargetRegisterClass *SrcRC,
70 for (int i = 0, e = sizeof(map)/sizeof(map[0]); i != e; ++ i)
71 if (DstRC == map[i].cls) {
72 const TargetInstrDesc &TID = get(map[i].opcode);
73 MachineInstr *MI = BuildMI(MBB, I, DL, TID, DstReg).addReg(SrcReg);
74 AddDefaultPredicate(MI);
81 bool PTXInstrInfo::isMoveInstr(const MachineInstr& MI,
82 unsigned &SrcReg, unsigned &DstReg,
83 unsigned &SrcSubIdx, unsigned &DstSubIdx) const {
84 switch (MI.getOpcode()) {
93 assert(MI.getNumOperands() >= 2 &&
94 MI.getOperand(0).isReg() && MI.getOperand(1).isReg() &&
95 "Invalid register-register move instruction");
96 SrcSubIdx = DstSubIdx = 0; // No sub-registers
97 DstReg = MI.getOperand(0).getReg();
98 SrcReg = MI.getOperand(1).getReg();
105 bool PTXInstrInfo::isPredicated(const MachineInstr *MI) const {
106 int i = MI->findFirstPredOperandIdx();
107 return i != -1 && MI->getOperand(i).getReg() != PTX::NoRegister;
110 bool PTXInstrInfo::isUnpredicatedTerminator(const MachineInstr *MI) const {
111 return !isPredicated(MI) && get(MI->getOpcode()).isTerminator();
115 PredicateInstruction(MachineInstr *MI,
116 const SmallVectorImpl<MachineOperand> &Pred) const {
118 llvm_unreachable("lesser than 2 predicate operands are provided");
120 int i = MI->findFirstPredOperandIdx();
122 llvm_unreachable("missing predicate operand");
124 MI->getOperand(i).setReg(Pred[0].getReg());
125 MI->getOperand(i+1).setImm(Pred[1].getImm());
131 SubsumesPredicate(const SmallVectorImpl<MachineOperand> &Pred1,
132 const SmallVectorImpl<MachineOperand> &Pred2) const {
133 const MachineOperand &PredReg1 = Pred1[0];
134 const MachineOperand &PredReg2 = Pred2[0];
135 if (PredReg1.getReg() != PredReg2.getReg())
138 const MachineOperand &PredOp1 = Pred1[1];
139 const MachineOperand &PredOp2 = Pred2[1];
140 if (PredOp1.getImm() != PredOp2.getImm())
147 DefinesPredicate(MachineInstr *MI,
148 std::vector<MachineOperand> &Pred) const {
149 // If an instruction sets a predicate register, it defines a predicate.
151 // TODO supprot 5-operand format of setp instruction
153 if (MI->getNumOperands() < 1)
156 const MachineOperand &MO = MI->getOperand(0);
158 if (!MO.isReg() || RI.getRegClass(MO.getReg()) != &PTX::PredsRegClass)
162 Pred.push_back(MachineOperand::CreateImm(PTX::PRED_NORMAL));
169 AnalyzeBranch(MachineBasicBlock &MBB,
170 MachineBasicBlock *&TBB,
171 MachineBasicBlock *&FBB,
172 SmallVectorImpl<MachineOperand> &Cond,
173 bool AllowModify) const {
174 // TODO implement cases when AllowModify is true
179 MachineBasicBlock::const_iterator iter = MBB.end();
180 const MachineInstr& instLast1 = *--iter;
181 const TargetInstrDesc &desc1 = instLast1.getDesc();
182 // for special case that MBB has only 1 instruction
183 const bool IsSizeOne = MBB.size() == 1;
184 // if IsSizeOne is true, *--iter and instLast2 are invalid
185 // we put a dummy value in instLast2 and desc2 since they are used
186 const MachineInstr& instLast2 = IsSizeOne ? instLast1 : *--iter;
187 const TargetInstrDesc &desc2 = IsSizeOne ? desc1 : instLast2.getDesc();
189 DEBUG(dbgs() << "\n");
190 DEBUG(dbgs() << "AnalyzeBranch: opcode: " << instLast1.getOpcode() << "\n");
191 DEBUG(dbgs() << "AnalyzeBranch: MBB: " << MBB.getName().str() << "\n");
192 DEBUG(dbgs() << "AnalyzeBranch: TBB: " << TBB << "\n");
193 DEBUG(dbgs() << "AnalyzeBranch: FBB: " << FBB << "\n");
195 // this block ends with no branches
196 if (!IsAnyKindOfBranch(instLast1)) {
197 DEBUG(dbgs() << "AnalyzeBranch: ends with no branch\n");
201 // this block ends with only an unconditional branch
202 if (desc1.isUnconditionalBranch() &&
203 // when IsSizeOne is true, it "absorbs" the evaluation of instLast2
204 (IsSizeOne || !IsAnyKindOfBranch(instLast2))) {
205 DEBUG(dbgs() << "AnalyzeBranch: ends with only uncond branch\n");
206 TBB = GetBranchTarget(instLast1);
210 // this block ends with a conditional branch and
211 // it falls through to a successor block
212 if (desc1.isConditionalBranch() &&
213 IsAnySuccessorAlsoLayoutSuccessor(MBB)) {
214 DEBUG(dbgs() << "AnalyzeBranch: ends with cond branch and fall through\n");
215 TBB = GetBranchTarget(instLast1);
216 int i = instLast1.findFirstPredOperandIdx();
217 Cond.push_back(instLast1.getOperand(i));
218 Cond.push_back(instLast1.getOperand(i+1));
222 // when IsSizeOne is true, we are done
226 // this block ends with a conditional branch
227 // followed by an unconditional branch
228 if (desc2.isConditionalBranch() &&
229 desc1.isUnconditionalBranch()) {
230 DEBUG(dbgs() << "AnalyzeBranch: ends with cond and uncond branch\n");
231 TBB = GetBranchTarget(instLast2);
232 FBB = GetBranchTarget(instLast1);
233 int i = instLast2.findFirstPredOperandIdx();
234 Cond.push_back(instLast2.getOperand(i));
235 Cond.push_back(instLast2.getOperand(i+1));
239 // branch cannot be understood
240 DEBUG(dbgs() << "AnalyzeBranch: cannot be understood\n");
244 unsigned PTXInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
247 if (IsAnyKindOfBranch(MBB.back())) {
252 DEBUG(dbgs() << "RemoveBranch: MBB: " << MBB.getName().str() << "\n");
253 DEBUG(dbgs() << "RemoveBranch: remove " << count << " branch inst\n");
257 unsigned PTXInstrInfo::
258 InsertBranch(MachineBasicBlock &MBB,
259 MachineBasicBlock *TBB,
260 MachineBasicBlock *FBB,
261 const SmallVectorImpl<MachineOperand> &Cond,
263 DEBUG(dbgs() << "InsertBranch: MBB: " << MBB.getName().str() << "\n");
264 DEBUG(if (TBB) dbgs() << "InsertBranch: TBB: " << TBB->getName().str()
266 else dbgs() << "InsertBranch: TBB: (NULL)\n");
267 DEBUG(if (FBB) dbgs() << "InsertBranch: FBB: " << FBB->getName().str()
269 else dbgs() << "InsertBranch: FBB: (NULL)\n");
270 DEBUG(dbgs() << "InsertBranch: Cond size: " << Cond.size() << "\n");
272 assert(TBB && "TBB is NULL");
275 BuildMI(&MBB, DL, get(PTX::BRAdp))
276 .addMBB(TBB).addReg(Cond[0].getReg()).addImm(Cond[1].getImm());
277 BuildMI(&MBB, DL, get(PTX::BRAd))
278 .addMBB(FBB).addReg(PTX::NoRegister).addImm(PTX::PRED_NORMAL);
280 } else if (Cond.size()) {
281 BuildMI(&MBB, DL, get(PTX::BRAdp))
282 .addMBB(TBB).addReg(Cond[0].getReg()).addImm(Cond[1].getImm());
285 BuildMI(&MBB, DL, get(PTX::BRAd))
286 .addMBB(TBB).addReg(PTX::NoRegister).addImm(PTX::PRED_NORMAL);
291 // static helper routines
293 MachineSDNode *PTXInstrInfo::
294 GetPTXMachineNode(SelectionDAG *DAG, unsigned Opcode,
295 DebugLoc dl, EVT VT, SDValue Op1) {
296 SDValue predReg = DAG->getRegister(PTX::NoRegister, MVT::i1);
297 SDValue predOp = DAG->getTargetConstant(PTX::PRED_NORMAL, MVT::i32);
298 SDValue ops[] = { Op1, predReg, predOp };
299 return DAG->getMachineNode(Opcode, dl, VT, ops, array_lengthof(ops));
302 MachineSDNode *PTXInstrInfo::
303 GetPTXMachineNode(SelectionDAG *DAG, unsigned Opcode,
304 DebugLoc dl, EVT VT, SDValue Op1, SDValue Op2) {
305 SDValue predReg = DAG->getRegister(PTX::NoRegister, MVT::i1);
306 SDValue predOp = DAG->getTargetConstant(PTX::PRED_NORMAL, MVT::i32);
307 SDValue ops[] = { Op1, Op2, predReg, predOp };
308 return DAG->getMachineNode(Opcode, dl, VT, ops, array_lengthof(ops));
311 void PTXInstrInfo::AddDefaultPredicate(MachineInstr *MI) {
312 if (MI->findFirstPredOperandIdx() == -1) {
313 MI->addOperand(MachineOperand::CreateReg(PTX::NoRegister, /*IsDef=*/false));
314 MI->addOperand(MachineOperand::CreateImm(PTX::PRED_NORMAL));
318 bool PTXInstrInfo::IsAnyKindOfBranch(const MachineInstr& inst) {
319 const TargetInstrDesc &desc = inst.getDesc();
320 return desc.isTerminator() || desc.isBranch() || desc.isIndirectBranch();
324 IsAnySuccessorAlsoLayoutSuccessor(const MachineBasicBlock& MBB) {
325 for (MachineBasicBlock::const_succ_iterator
326 i = MBB.succ_begin(), e = MBB.succ_end(); i != e; ++i)
327 if (MBB.isLayoutSuccessor((const MachineBasicBlock*) &*i))
332 MachineBasicBlock *PTXInstrInfo::GetBranchTarget(const MachineInstr& inst) {
333 // FIXME So far all branch instructions put destination in 1st operand
334 const MachineOperand& target = inst.getOperand(0);
335 assert(target.isMBB() && "FIXME: detect branch target operand");
336 return target.getMBB();