LLVM 24.0.0git
R600InstrInfo.cpp
Go to the documentation of this file.
1//===-- R600InstrInfo.cpp - R600 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/// \file
10/// R600 Implementation of TargetInstrInfo.
11//
12//===----------------------------------------------------------------------===//
13
14#include "R600InstrInfo.h"
16#include "R600Defines.h"
17#include "R600Subtarget.h"
19
20using namespace llvm;
21
22#define GET_INSTRINFO_CTOR_DTOR
23#include "R600GenDFAPacketizer.inc"
24
25#define GET_INSTRINFO_CTOR_DTOR
26#define GET_INSTRMAP_INFO
27#define GET_INSTRINFO_NAMED_OPS
28#include "R600GenInstrInfo.inc"
29
31 : R600GenInstrInfo(ST, RI, -1, -1), RI(), ST(ST) {}
32
34 return get(MI.getOpcode()).TSFlags & R600_InstFlag::VECTOR;
35}
36
39 const DebugLoc &DL, Register DestReg,
40 Register SrcReg, bool KillSrc,
41 bool RenamableDest, bool RenamableSrc) const {
42 unsigned VectorComponents = 0;
43 if ((R600::R600_Reg128RegClass.contains(DestReg) ||
44 R600::R600_Reg128VerticalRegClass.contains(DestReg)) &&
45 (R600::R600_Reg128RegClass.contains(SrcReg) ||
46 R600::R600_Reg128VerticalRegClass.contains(SrcReg))) {
47 VectorComponents = 4;
48 } else if((R600::R600_Reg64RegClass.contains(DestReg) ||
49 R600::R600_Reg64VerticalRegClass.contains(DestReg)) &&
50 (R600::R600_Reg64RegClass.contains(SrcReg) ||
51 R600::R600_Reg64VerticalRegClass.contains(SrcReg))) {
52 VectorComponents = 2;
53 }
54
55 if (VectorComponents > 0) {
56 for (unsigned I = 0; I < VectorComponents; I++) {
57 unsigned SubRegIndex = R600RegisterInfo::getSubRegFromChannel(I);
58 buildDefaultInstruction(MBB, MI, R600::MOV,
59 RI.getSubReg(DestReg, SubRegIndex),
60 RI.getSubReg(SrcReg, SubRegIndex))
61 .addReg(DestReg,
63 }
64 } else {
65 MachineInstr *NewMI = buildDefaultInstruction(MBB, MI, R600::MOV,
66 DestReg, SrcReg);
67 NewMI->getOperand(getOperandIdx(*NewMI, R600::OpName::src0))
68 .setIsKill(KillSrc);
69 }
70}
71
72/// \returns true if \p MBBI can be moved into a new basic.
75 for (const MachineOperand &MO : MBBI->all_uses())
76 if (!MO.getReg().isVirtual() && RI.isPhysRegLiveAcrossClauses(MO.getReg()))
77 return false;
78 return true;
79}
80
81bool R600InstrInfo::isMov(unsigned Opcode) const {
82 switch(Opcode) {
83 default:
84 return false;
85 case R600::MOV:
86 case R600::MOV_IMM_F32:
87 case R600::MOV_IMM_I32:
88 return true;
89 }
90}
91
92bool R600InstrInfo::isReductionOp(unsigned Opcode) const {
93 return false;
94}
95
96bool R600InstrInfo::isCubeOp(unsigned Opcode) const {
97 switch(Opcode) {
98 default: return false;
99 case R600::CUBE_r600_pseudo:
100 case R600::CUBE_r600_real:
101 case R600::CUBE_eg_pseudo:
102 case R600::CUBE_eg_real:
103 return true;
104 }
105}
106
107bool R600InstrInfo::isALUInstr(unsigned Opcode) const {
108 unsigned TargetFlags = get(Opcode).TSFlags;
109
110 return (TargetFlags & R600_InstFlag::ALU_INST);
111}
112
113bool R600InstrInfo::hasInstrModifiers(unsigned Opcode) const {
114 unsigned TargetFlags = get(Opcode).TSFlags;
115
116 return ((TargetFlags & R600_InstFlag::OP1) |
117 (TargetFlags & R600_InstFlag::OP2) |
118 (TargetFlags & R600_InstFlag::OP3));
119}
120
121bool R600InstrInfo::isLDSInstr(unsigned Opcode) const {
122 unsigned TargetFlags = get(Opcode).TSFlags;
123
124 return ((TargetFlags & R600_InstFlag::LDS_1A) |
125 (TargetFlags & R600_InstFlag::LDS_1A1D) |
126 (TargetFlags & R600_InstFlag::LDS_1A2D));
127}
128
129bool R600InstrInfo::isLDSRetInstr(unsigned Opcode) const {
130 return isLDSInstr(Opcode) && getOperandIdx(Opcode, R600::OpName::dst) != -1;
131}
132
134 if (isALUInstr(MI.getOpcode()))
135 return true;
136 if (isVector(MI) || isCubeOp(MI.getOpcode()))
137 return true;
138 switch (MI.getOpcode()) {
139 case R600::PRED_X:
140 case R600::INTERP_PAIR_XY:
141 case R600::INTERP_PAIR_ZW:
142 case R600::INTERP_VEC_LOAD:
143 case R600::COPY:
144 case R600::DOT_4:
145 return true;
146 default:
147 return false;
148 }
149}
150
151bool R600InstrInfo::isTransOnly(unsigned Opcode) const {
152 if (ST.hasCaymanISA())
153 return false;
154 return (get(Opcode).getSchedClass() == R600::Sched::TransALU);
155}
156
158 return isTransOnly(MI.getOpcode());
159}
160
161bool R600InstrInfo::isVectorOnly(unsigned Opcode) const {
162 return (get(Opcode).getSchedClass() == R600::Sched::VecALU);
163}
164
166 return isVectorOnly(MI.getOpcode());
167}
168
169bool R600InstrInfo::isExport(unsigned Opcode) const {
170 return (get(Opcode).TSFlags & R600_InstFlag::IS_EXPORT);
171}
172
173bool R600InstrInfo::usesVertexCache(unsigned Opcode) const {
174 return ST.hasVertexCache() && IS_VTX(get(Opcode));
175}
176
178 const MachineFunction *MF = MI.getMF();
180 usesVertexCache(MI.getOpcode());
181}
182
183bool R600InstrInfo::usesTextureCache(unsigned Opcode) const {
184 return (!ST.hasVertexCache() && IS_VTX(get(Opcode))) || IS_TEX(get(Opcode));
185}
186
188 const MachineFunction *MF = MI.getMF();
190 usesVertexCache(MI.getOpcode())) ||
191 usesTextureCache(MI.getOpcode());
192}
193
194bool R600InstrInfo::mustBeLastInClause(unsigned Opcode) const {
195 switch (Opcode) {
196 case R600::KILLGT:
197 case R600::GROUP_BARRIER:
198 return true;
199 default:
200 return false;
201 }
202}
203
205 return MI.findRegisterUseOperandIdx(R600::AR_X, &RI, false) != -1;
206}
207
209 return MI.findRegisterDefOperandIdx(R600::AR_X, &RI, false, false) != -1;
210}
211
213 if (!isALUInstr(MI.getOpcode())) {
214 return false;
215 }
216 for (const MachineOperand &MO : MI.all_uses())
217 if (MO.getReg().isPhysical() &&
218 R600::R600_LDS_SRC_REGRegClass.contains(MO.getReg()))
219 return true;
220 return false;
221}
222
223int R600InstrInfo::getSelIdx(unsigned Opcode, unsigned SrcIdx) const {
224 static const R600::OpName SrcSelTable[][2] = {
225 {R600::OpName::src0, R600::OpName::src0_sel},
226 {R600::OpName::src1, R600::OpName::src1_sel},
227 {R600::OpName::src2, R600::OpName::src2_sel},
228 {R600::OpName::src0_X, R600::OpName::src0_sel_X},
229 {R600::OpName::src0_Y, R600::OpName::src0_sel_Y},
230 {R600::OpName::src0_Z, R600::OpName::src0_sel_Z},
231 {R600::OpName::src0_W, R600::OpName::src0_sel_W},
232 {R600::OpName::src1_X, R600::OpName::src1_sel_X},
233 {R600::OpName::src1_Y, R600::OpName::src1_sel_Y},
234 {R600::OpName::src1_Z, R600::OpName::src1_sel_Z},
235 {R600::OpName::src1_W, R600::OpName::src1_sel_W}};
236
237 for (const auto &Row : SrcSelTable) {
238 if (getOperandIdx(Opcode, Row[0]) == (int)SrcIdx) {
239 return getOperandIdx(Opcode, Row[1]);
240 }
241 }
242 return -1;
243}
244
248
249 if (MI.getOpcode() == R600::DOT_4) {
250 static const R600::OpName OpTable[8][2] = {
251 {R600::OpName::src0_X, R600::OpName::src0_sel_X},
252 {R600::OpName::src0_Y, R600::OpName::src0_sel_Y},
253 {R600::OpName::src0_Z, R600::OpName::src0_sel_Z},
254 {R600::OpName::src0_W, R600::OpName::src0_sel_W},
255 {R600::OpName::src1_X, R600::OpName::src1_sel_X},
256 {R600::OpName::src1_Y, R600::OpName::src1_sel_Y},
257 {R600::OpName::src1_Z, R600::OpName::src1_sel_Z},
258 {R600::OpName::src1_W, R600::OpName::src1_sel_W},
259 };
260
261 for (const auto &Op : OpTable) {
262 MachineOperand &MO = MI.getOperand(getOperandIdx(MI.getOpcode(), Op[0]));
263 Register Reg = MO.getReg();
264 if (Reg == R600::ALU_CONST) {
265 MachineOperand &Sel =
266 MI.getOperand(getOperandIdx(MI.getOpcode(), Op[1]));
267 Result.push_back(std::pair(&MO, Sel.getImm()));
268 continue;
269 }
270 }
271 return Result;
272 }
273
274 static const R600::OpName OpTable[3][2] = {
275 {R600::OpName::src0, R600::OpName::src0_sel},
276 {R600::OpName::src1, R600::OpName::src1_sel},
277 {R600::OpName::src2, R600::OpName::src2_sel},
278 };
279
280 for (const auto &Op : OpTable) {
281 int SrcIdx = getOperandIdx(MI.getOpcode(), Op[0]);
282 if (SrcIdx < 0)
283 break;
284 MachineOperand &MO = MI.getOperand(SrcIdx);
285 Register Reg = MO.getReg();
286 if (Reg == R600::ALU_CONST) {
287 MachineOperand &Sel = MI.getOperand(getOperandIdx(MI.getOpcode(), Op[1]));
288 Result.push_back(std::pair(&MO, Sel.getImm()));
289 continue;
290 }
291 if (Reg == R600::ALU_LITERAL_X) {
292 MachineOperand &Operand =
293 MI.getOperand(getOperandIdx(MI.getOpcode(), R600::OpName::literal));
294 if (Operand.isImm()) {
295 Result.push_back(std::pair(&MO, Operand.getImm()));
296 continue;
297 }
298 assert(Operand.isGlobal());
299 }
300 Result.push_back(std::pair(&MO, 0));
301 }
302 return Result;
303}
304
305std::vector<std::pair<int, unsigned>>
306R600InstrInfo::ExtractSrcs(MachineInstr &MI,
308 unsigned &ConstCount) const {
309 ConstCount = 0;
310 const std::pair<int, unsigned> DummyPair(-1, 0);
311 std::vector<std::pair<int, unsigned>> Result;
312 unsigned i = 0;
313 for (const auto &Src : getSrcs(MI)) {
314 ++i;
315 Register Reg = Src.first->getReg();
316 int Index = RI.getEncodingValue(Reg) & 0xff;
317 if (Reg == R600::OQAP) {
318 Result.emplace_back(Index, 0U);
319 }
320 if (PV.contains(Reg)) {
321 // 255 is used to tells its a PS/PV reg
322 Result.emplace_back(255, 0U);
323 continue;
324 }
325 if (Index > 127) {
326 ConstCount++;
327 Result.push_back(DummyPair);
328 continue;
329 }
330 unsigned Chan = RI.getHWRegChan(Reg);
331 Result.emplace_back(Index, Chan);
332 }
333 for (; i < 3; ++i)
334 Result.push_back(DummyPair);
335 return Result;
336}
337
338static std::vector<std::pair<int, unsigned>>
339Swizzle(std::vector<std::pair<int, unsigned>> Src,
341 if (Src[0] == Src[1])
342 Src[1].first = -1;
343 switch (Swz) {
345 break;
347 std::swap(Src[1], Src[2]);
348 break;
350 std::swap(Src[0], Src[1]);
351 break;
353 std::swap(Src[0], Src[1]);
354 std::swap(Src[0], Src[2]);
355 break;
357 std::swap(Src[0], Src[2]);
358 std::swap(Src[0], Src[1]);
359 break;
361 std::swap(Src[0], Src[2]);
362 break;
363 }
364 return Src;
365}
366
367static unsigned getTransSwizzle(R600InstrInfo::BankSwizzle Swz, unsigned Op) {
368 assert(Op < 3 && "Out of range swizzle index");
369 switch (Swz) {
371 unsigned Cycles[3] = { 2, 1, 0};
372 return Cycles[Op];
373 }
375 unsigned Cycles[3] = { 1, 2, 2};
376 return Cycles[Op];
377 }
379 unsigned Cycles[3] = { 2, 1, 2};
380 return Cycles[Op];
381 }
383 unsigned Cycles[3] = { 2, 2, 1};
384 return Cycles[Op];
385 }
386 default:
387 llvm_unreachable("Wrong Swizzle for Trans Slot");
388 }
389}
390
391/// returns how many MIs (whose inputs are represented by IGSrcs) can be packed
392/// in the same Instruction Group while meeting read port limitations given a
393/// Swz swizzle sequence.
395 const std::vector<std::vector<std::pair<int, unsigned>>> &IGSrcs,
396 const std::vector<R600InstrInfo::BankSwizzle> &Swz,
397 const std::vector<std::pair<int, unsigned>> &TransSrcs,
398 R600InstrInfo::BankSwizzle TransSwz) const {
399 int Vector[4][3];
400 memset(Vector, -1, sizeof(Vector));
401 for (unsigned i = 0, e = IGSrcs.size(); i < e; i++) {
402 const std::vector<std::pair<int, unsigned>> &Srcs =
403 Swizzle(IGSrcs[i], Swz[i]);
404 for (unsigned j = 0; j < 3; j++) {
405 const std::pair<int, unsigned> &Src = Srcs[j];
406 if (Src.first < 0 || Src.first == 255)
407 continue;
408 if (Src.first == GET_REG_INDEX(RI.getEncodingValue(R600::OQAP))) {
411 // The value from output queue A (denoted by register OQAP) can
412 // only be fetched during the first cycle.
413 return false;
414 }
415 // OQAP does not count towards the normal read port restrictions
416 continue;
417 }
418 if (Vector[Src.second][j] < 0)
419 Vector[Src.second][j] = Src.first;
420 if (Vector[Src.second][j] != Src.first)
421 return i;
422 }
423 }
424 // Now check Trans Alu
425 for (unsigned i = 0, e = TransSrcs.size(); i < e; ++i) {
426 const std::pair<int, unsigned> &Src = TransSrcs[i];
427 unsigned Cycle = getTransSwizzle(TransSwz, i);
428 if (Src.first < 0)
429 continue;
430 if (Src.first == 255)
431 continue;
432 if (Vector[Src.second][Cycle] < 0)
433 Vector[Src.second][Cycle] = Src.first;
434 if (Vector[Src.second][Cycle] != Src.first)
435 return IGSrcs.size() - 1;
436 }
437 return IGSrcs.size();
438}
439
440/// Given a swizzle sequence SwzCandidate and an index Idx, returns the next
441/// (in lexicographic term) swizzle sequence assuming that all swizzles after
442/// Idx can be skipped
443static bool
445 std::vector<R600InstrInfo::BankSwizzle> &SwzCandidate,
446 unsigned Idx) {
447 assert(Idx < SwzCandidate.size());
448 int ResetIdx = Idx;
449 while (ResetIdx > -1 && SwzCandidate[ResetIdx] == R600InstrInfo::ALU_VEC_210)
450 ResetIdx --;
451 for (unsigned i = ResetIdx + 1, e = SwzCandidate.size(); i < e; i++) {
452 SwzCandidate[i] = R600InstrInfo::ALU_VEC_012_SCL_210;
453 }
454 if (ResetIdx == -1)
455 return false;
456 int NextSwizzle = SwzCandidate[ResetIdx] + 1;
457 SwzCandidate[ResetIdx] = (R600InstrInfo::BankSwizzle)NextSwizzle;
458 return true;
459}
460
461/// Enumerate all possible Swizzle sequence to find one that can meet all
462/// read port requirements.
464 const std::vector<std::vector<std::pair<int, unsigned>>> &IGSrcs,
465 std::vector<R600InstrInfo::BankSwizzle> &SwzCandidate,
466 const std::vector<std::pair<int, unsigned>> &TransSrcs,
467 R600InstrInfo::BankSwizzle TransSwz) const {
468 unsigned ValidUpTo = 0;
469 do {
470 ValidUpTo = isLegalUpTo(IGSrcs, SwzCandidate, TransSrcs, TransSwz);
471 if (ValidUpTo == IGSrcs.size())
472 return true;
473 } while (NextPossibleSolution(SwzCandidate, ValidUpTo));
474 return false;
475}
476
477/// Instructions in Trans slot can't read gpr at cycle 0 if they also read
478/// a const, and can't read a gpr at cycle 1 if they read 2 const.
479static bool
481 const std::vector<std::pair<int, unsigned>> &TransOps,
482 unsigned ConstCount) {
483 // TransALU can't read 3 constants
484 if (ConstCount > 2)
485 return false;
486 for (unsigned i = 0, e = TransOps.size(); i < e; ++i) {
487 const std::pair<int, unsigned> &Src = TransOps[i];
488 unsigned Cycle = getTransSwizzle(TransSwz, i);
489 if (Src.first < 0)
490 continue;
491 if (ConstCount > 0 && Cycle == 0)
492 return false;
493 if (ConstCount > 1 && Cycle == 1)
494 return false;
495 }
496 return true;
497}
498
499bool
500R600InstrInfo::fitsReadPortLimitations(const std::vector<MachineInstr *> &IG,
502 std::vector<BankSwizzle> &ValidSwizzle,
503 bool isLastAluTrans)
504 const {
505 //Todo : support shared src0 - src1 operand
506
507 std::vector<std::vector<std::pair<int, unsigned>>> IGSrcs;
508 ValidSwizzle.clear();
509 unsigned ConstCount;
511 for (MachineInstr *MI : IG) {
512 IGSrcs.push_back(ExtractSrcs(*MI, PV, ConstCount));
513 unsigned Op = getOperandIdx(MI->getOpcode(), R600::OpName::bank_swizzle);
514 ValidSwizzle.push_back(
515 (R600InstrInfo::BankSwizzle)MI->getOperand(Op).getImm());
516 }
517 std::vector<std::pair<int, unsigned>> TransOps;
518 if (!isLastAluTrans)
519 return FindSwizzleForVectorSlot(IGSrcs, ValidSwizzle, TransOps, TransBS);
520
521 TransOps = std::move(IGSrcs.back());
522 IGSrcs.pop_back();
523 ValidSwizzle.pop_back();
524
525 static const R600InstrInfo::BankSwizzle TransSwz[] = {
530 };
531 for (R600InstrInfo::BankSwizzle TransBS : TransSwz) {
532 if (!isConstCompatible(TransBS, TransOps, ConstCount))
533 continue;
534 bool Result = FindSwizzleForVectorSlot(IGSrcs, ValidSwizzle, TransOps,
535 TransBS);
536 if (Result) {
537 ValidSwizzle.push_back(TransBS);
538 return true;
539 }
540 }
541
542 return false;
543}
544
545bool
546R600InstrInfo::fitsConstReadLimitations(const std::vector<unsigned> &Consts)
547 const {
548 assert (Consts.size() <= 12 && "Too many operands in instructions group");
549 unsigned Pair1 = 0, Pair2 = 0;
550 for (unsigned Const : Consts) {
551 unsigned ReadConstHalf = Const & 2;
552 unsigned ReadConstIndex = Const & (~3);
553 unsigned ReadHalfConst = ReadConstIndex | ReadConstHalf;
554 if (!Pair1) {
555 Pair1 = ReadHalfConst;
556 continue;
557 }
558 if (Pair1 == ReadHalfConst)
559 continue;
560 if (!Pair2) {
561 Pair2 = ReadHalfConst;
562 continue;
563 }
564 if (Pair2 != ReadHalfConst)
565 return false;
566 }
567 return true;
568}
569
570bool
571R600InstrInfo::fitsConstReadLimitations(const std::vector<MachineInstr *> &MIs)
572 const {
573 std::vector<unsigned> Consts;
574 SmallSet<int64_t, 4> Literals;
575 for (MachineInstr *MI : MIs) {
576 if (!isALUInstr(MI->getOpcode()))
577 continue;
578
579 for (const auto &Src : getSrcs(*MI)) {
580 if (Src.first->getReg() == R600::ALU_LITERAL_X)
581 Literals.insert(Src.second);
582 if (Literals.size() > 4)
583 return false;
584 if (Src.first->getReg() == R600::ALU_CONST)
585 Consts.push_back(Src.second);
586 if (Src.first->getReg().isPhysical() &&
587 (R600::R600_KC0RegClass.contains(Src.first->getReg()) ||
588 R600::R600_KC1RegClass.contains(Src.first->getReg()))) {
589 unsigned Index = RI.getEncodingValue(Src.first->getReg()) & 0xff;
590 unsigned Chan = RI.getHWRegChan(Src.first->getReg());
591 Consts.push_back((Index << 2) | Chan);
592 }
593 }
594 }
595 return fitsConstReadLimitations(Consts);
596}
597
601 return static_cast<const R600Subtarget &>(STI).createDFAPacketizer(II);
602}
603
604static bool
605isPredicateSetter(unsigned Opcode) {
606 switch (Opcode) {
607 case R600::PRED_X:
608 return true;
609 default:
610 return false;
611 }
612}
613
614static MachineInstr *
617 while (I != MBB.begin()) {
618 --I;
619 MachineInstr &MI = *I;
620 if (isPredicateSetter(MI.getOpcode()))
621 return &MI;
622 }
623
624 return nullptr;
625}
626
627static
628bool isJump(unsigned Opcode) {
629 return Opcode == R600::JUMP || Opcode == R600::JUMP_COND;
630}
631
632static bool isBranch(unsigned Opcode) {
633 return Opcode == R600::BRANCH || Opcode == R600::BRANCH_COND_i32 ||
634 Opcode == R600::BRANCH_COND_f32;
635}
636
639 MachineBasicBlock *&FBB,
641 bool AllowModify) const {
642 // Most of the following comes from the ARM implementation of analyzeBranch
643
644 // If the block has no terminators, it just falls into the block after it.
645 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
646 if (I == MBB.end())
647 return false;
648
649 // R600::BRANCH* instructions are only available after isel and are not
650 // handled
651 if (isBranch(I->getOpcode()))
652 return true;
653 if (!isJump(I->getOpcode())) {
654 return false;
655 }
656
657 // Remove successive JUMP
658 while (I != MBB.begin() && std::prev(I)->getOpcode() == R600::JUMP) {
659 MachineBasicBlock::iterator PriorI = std::prev(I);
660 if (AllowModify)
661 I->removeFromParent();
662 I = PriorI;
663 }
664 MachineInstr &LastInst = *I;
665
666 // If there is only one terminator instruction, process it.
667 unsigned LastOpc = LastInst.getOpcode();
668 if (I == MBB.begin() || !isJump((--I)->getOpcode())) {
669 if (LastOpc == R600::JUMP) {
670 TBB = LastInst.getOperand(0).getMBB();
671 return false;
672 }
673 if (LastOpc == R600::JUMP_COND) {
674 auto predSet = I;
675 while (!isPredicateSetter(predSet->getOpcode())) {
676 predSet = --I;
677 }
678 TBB = LastInst.getOperand(0).getMBB();
679 Cond.push_back(predSet->getOperand(1));
680 Cond.push_back(predSet->getOperand(2));
681 Cond.push_back(MachineOperand::CreateReg(R600::PRED_SEL_ONE, false));
682 return false;
683 }
684 return true; // Can't handle indirect branch.
685 }
686
687 // Get the instruction before it if it is a terminator.
688 MachineInstr &SecondLastInst = *I;
689 unsigned SecondLastOpc = SecondLastInst.getOpcode();
690
691 // If the block ends with a B and a Bcc, handle it.
692 if (SecondLastOpc == R600::JUMP_COND && LastOpc == R600::JUMP) {
693 auto predSet = --I;
694 while (!isPredicateSetter(predSet->getOpcode())) {
695 predSet = --I;
696 }
697 TBB = SecondLastInst.getOperand(0).getMBB();
698 FBB = LastInst.getOperand(0).getMBB();
699 Cond.push_back(predSet->getOperand(1));
700 Cond.push_back(predSet->getOperand(2));
701 Cond.push_back(MachineOperand::CreateReg(R600::PRED_SEL_ONE, false));
702 return false;
703 }
704
705 // Otherwise, can't handle this.
706 return true;
707}
708
709static
711 for (MachineBasicBlock::reverse_iterator It = MBB.rbegin(), E = MBB.rend();
712 It != E; ++It) {
713 if (It->getOpcode() == R600::CF_ALU ||
714 It->getOpcode() == R600::CF_ALU_PUSH_BEFORE)
715 return It.getReverse();
716 }
717 return MBB.end();
718}
719
724 const DebugLoc &DL,
725 int *BytesAdded) const {
726 assert(TBB && "insertBranch must not be told to insert a fallthrough");
727 assert(!BytesAdded && "code size not handled");
728
729 if (!FBB) {
730 if (Cond.empty()) {
731 BuildMI(&MBB, DL, get(R600::JUMP)).addMBB(TBB);
732 return 1;
733 }
735 assert(PredSet && "No previous predicate !");
737 PredSet->getOperand(2).setImm(Cond[1].getImm());
738
739 BuildMI(&MBB, DL, get(R600::JUMP_COND))
740 .addMBB(TBB)
741 .addReg(R600::PREDICATE_BIT, RegState::Kill);
743 if (CfAlu == MBB.end())
744 return 1;
745 assert (CfAlu->getOpcode() == R600::CF_ALU);
746 CfAlu->setDesc(get(R600::CF_ALU_PUSH_BEFORE));
747 return 1;
748 }
750 assert(PredSet && "No previous predicate !");
752 PredSet->getOperand(2).setImm(Cond[1].getImm());
753 BuildMI(&MBB, DL, get(R600::JUMP_COND))
754 .addMBB(TBB)
755 .addReg(R600::PREDICATE_BIT, RegState::Kill);
756 BuildMI(&MBB, DL, get(R600::JUMP)).addMBB(FBB);
758 if (CfAlu == MBB.end())
759 return 2;
760 assert(CfAlu->getOpcode() == R600::CF_ALU);
761 CfAlu->setDesc(get(R600::CF_ALU_PUSH_BEFORE));
762 return 2;
763}
764
766 int *BytesRemoved) const {
767 assert(!BytesRemoved && "code size not handled");
768
769 // Note : we leave PRED* instructions there.
770 // They may be needed when predicating instructions.
771
773
774 if (I == MBB.begin()) {
775 return 0;
776 }
777 --I;
778 switch (I->getOpcode()) {
779 default:
780 return 0;
781 case R600::JUMP_COND: {
783 clearFlag(*predSet, 0, MO_FLAG_PUSH);
784 I->eraseFromParent();
786 if (CfAlu == MBB.end())
787 break;
788 assert (CfAlu->getOpcode() == R600::CF_ALU_PUSH_BEFORE);
789 CfAlu->setDesc(get(R600::CF_ALU));
790 break;
791 }
792 case R600::JUMP:
793 I->eraseFromParent();
794 break;
795 }
796 I = MBB.end();
797
798 if (I == MBB.begin()) {
799 return 1;
800 }
801 --I;
802 switch (I->getOpcode()) {
803 // FIXME: only one case??
804 default:
805 return 1;
806 case R600::JUMP_COND: {
808 clearFlag(*predSet, 0, MO_FLAG_PUSH);
809 I->eraseFromParent();
811 if (CfAlu == MBB.end())
812 break;
813 assert (CfAlu->getOpcode() == R600::CF_ALU_PUSH_BEFORE);
814 CfAlu->setDesc(get(R600::CF_ALU));
815 break;
816 }
817 case R600::JUMP:
818 I->eraseFromParent();
819 break;
820 }
821 return 2;
822}
823
825 int idx = MI.findFirstPredOperandIdx();
826 if (idx < 0)
827 return false;
828
829 Register Reg = MI.getOperand(idx).getReg();
830 switch (Reg) {
831 default: return false;
832 case R600::PRED_SEL_ONE:
833 case R600::PRED_SEL_ZERO:
834 case R600::PREDICATE_BIT:
835 return true;
836 }
837}
838
840 // XXX: KILL* instructions can be predicated, but they must be the last
841 // instruction in a clause, so this means any instructions after them cannot
842 // be predicated. Until we have proper support for instruction clauses in the
843 // backend, we will mark KILL* instructions as unpredicable.
844
845 if (MI.getOpcode() == R600::KILLGT)
846 return false;
847 if (MI.getOpcode() == R600::CF_ALU) {
848 // If the clause start in the middle of MBB then the MBB has more
849 // than a single clause, unable to predicate several clauses.
850 if (MI.getParent()->begin() != MachineBasicBlock::const_iterator(MI))
851 return false;
852 // TODO: We don't support KC merging atm
853 return MI.getOperand(3).getImm() == 0 && MI.getOperand(4).getImm() == 0;
854 }
855 if (isVector(MI))
856 return false;
858}
859
860bool
862 unsigned NumCycles,
863 unsigned ExtraPredCycles,
864 BranchProbability Probability) const{
865 return true;
866}
867
868bool
870 unsigned NumTCycles,
871 unsigned ExtraTCycles,
872 MachineBasicBlock &FMBB,
873 unsigned NumFCycles,
874 unsigned ExtraFCycles,
875 BranchProbability Probability) const {
876 return true;
877}
878
879bool
881 unsigned NumCycles,
882 BranchProbability Probability)
883 const {
884 return true;
885}
886
887bool
889 MachineBasicBlock &FMBB) const {
890 return false;
891}
892
893bool
895 MachineOperand &MO = Cond[1];
896 switch (MO.getImm()) {
897 case R600::PRED_SETE_INT:
898 MO.setImm(R600::PRED_SETNE_INT);
899 break;
900 case R600::PRED_SETNE_INT:
901 MO.setImm(R600::PRED_SETE_INT);
902 break;
903 case R600::PRED_SETE:
904 MO.setImm(R600::PRED_SETNE);
905 break;
906 case R600::PRED_SETNE:
907 MO.setImm(R600::PRED_SETE);
908 break;
909 default:
910 return true;
911 }
912
913 MachineOperand &MO2 = Cond[2];
914 switch (MO2.getReg()) {
915 case R600::PRED_SEL_ZERO:
916 MO2.setReg(R600::PRED_SEL_ONE);
917 break;
918 case R600::PRED_SEL_ONE:
919 MO2.setReg(R600::PRED_SEL_ZERO);
920 break;
921 default:
922 return true;
923 }
924 return false;
925}
926
928 std::vector<MachineOperand> &Pred,
929 bool SkipDead) const {
930 return isPredicateSetter(MI.getOpcode());
931}
932
934 ArrayRef<MachineOperand> Pred) const {
935 int PIdx = MI.findFirstPredOperandIdx();
936
937 if (MI.getOpcode() == R600::CF_ALU) {
938 MI.getOperand(8).setImm(0);
939 return true;
940 }
941
942 if (MI.getOpcode() == R600::DOT_4) {
943 MI.getOperand(getOperandIdx(MI, R600::OpName::pred_sel_X))
944 .setReg(Pred[2].getReg());
945 MI.getOperand(getOperandIdx(MI, R600::OpName::pred_sel_Y))
946 .setReg(Pred[2].getReg());
947 MI.getOperand(getOperandIdx(MI, R600::OpName::pred_sel_Z))
948 .setReg(Pred[2].getReg());
949 MI.getOperand(getOperandIdx(MI, R600::OpName::pred_sel_W))
950 .setReg(Pred[2].getReg());
951 MachineInstrBuilder MIB(*MI.getMF(), MI);
952 MIB.addReg(R600::PREDICATE_BIT, RegState::Implicit);
953 return true;
954 }
955
956 if (PIdx != -1) {
957 MachineOperand &PMO = MI.getOperand(PIdx);
958 PMO.setReg(Pred[2].getReg());
959 MachineInstrBuilder MIB(*MI.getMF(), MI);
960 MIB.addReg(R600::PREDICATE_BIT, RegState::Implicit);
961 return true;
962 }
963
964 return false;
965}
966
968 return 2;
969}
970
972 const MachineInstr &,
973 unsigned *PredCost) const {
974 if (PredCost)
975 *PredCost = 2;
976 return 2;
977}
978
980 unsigned Channel) const {
981 assert(Channel == 0);
982 return RegIndex;
983}
984
986 switch (MI.getOpcode()) {
987 default: {
988 MachineBasicBlock *MBB = MI.getParent();
989 int OffsetOpIdx =
990 R600::getNamedOperandIdx(MI.getOpcode(), R600::OpName::addr);
991 // addr is a custom operand with multiple MI operands, and only the
992 // first MI operand is given a name.
993 int RegOpIdx = OffsetOpIdx + 1;
994 int ChanOpIdx =
995 R600::getNamedOperandIdx(MI.getOpcode(), R600::OpName::chan);
996 if (isRegisterLoad(MI)) {
997 int DstOpIdx =
998 R600::getNamedOperandIdx(MI.getOpcode(), R600::OpName::dst);
999 unsigned RegIndex = MI.getOperand(RegOpIdx).getImm();
1000 unsigned Channel = MI.getOperand(ChanOpIdx).getImm();
1001 unsigned Address = calculateIndirectAddress(RegIndex, Channel);
1002 Register OffsetReg = MI.getOperand(OffsetOpIdx).getReg();
1003 if (OffsetReg == R600::INDIRECT_BASE_ADDR) {
1004 buildMovInstr(MBB, MI, MI.getOperand(DstOpIdx).getReg(),
1005 getIndirectAddrRegClass()->getRegister(Address));
1006 } else {
1007 buildIndirectRead(MBB, MI, MI.getOperand(DstOpIdx).getReg(), Address,
1008 OffsetReg);
1009 }
1010 } else if (isRegisterStore(MI)) {
1011 int ValOpIdx =
1012 R600::getNamedOperandIdx(MI.getOpcode(), R600::OpName::val);
1013 unsigned RegIndex = MI.getOperand(RegOpIdx).getImm();
1014 unsigned Channel = MI.getOperand(ChanOpIdx).getImm();
1015 unsigned Address = calculateIndirectAddress(RegIndex, Channel);
1016 Register OffsetReg = MI.getOperand(OffsetOpIdx).getReg();
1017 if (OffsetReg == R600::INDIRECT_BASE_ADDR) {
1019 MI.getOperand(ValOpIdx).getReg());
1020 } else {
1021 buildIndirectWrite(MBB, MI, MI.getOperand(ValOpIdx).getReg(),
1022 calculateIndirectAddress(RegIndex, Channel),
1023 OffsetReg);
1024 }
1025 } else {
1026 return false;
1027 }
1028
1029 MBB->erase(MI);
1030 return true;
1031 }
1032 case R600::R600_EXTRACT_ELT_V2:
1033 case R600::R600_EXTRACT_ELT_V4:
1034 buildIndirectRead(MI.getParent(), MI, MI.getOperand(0).getReg(),
1035 RI.getHWRegIndex(MI.getOperand(1).getReg()), // Address
1036 MI.getOperand(2).getReg(),
1037 RI.getHWRegChan(MI.getOperand(1).getReg()));
1038 break;
1039 case R600::R600_INSERT_ELT_V2:
1040 case R600::R600_INSERT_ELT_V4:
1041 buildIndirectWrite(MI.getParent(), MI, MI.getOperand(2).getReg(), // Value
1042 RI.getHWRegIndex(MI.getOperand(1).getReg()), // Address
1043 MI.getOperand(3).getReg(), // Offset
1044 RI.getHWRegChan(MI.getOperand(1).getReg())); // Channel
1045 break;
1046 }
1047 MI.eraseFromParent();
1048 return true;
1049}
1050
1052 const MachineFunction &MF,
1053 const R600RegisterInfo &TRI) const {
1054 const R600Subtarget &ST = MF.getSubtarget<R600Subtarget>();
1055 const R600FrameLowering *TFL = ST.getFrameLowering();
1056
1057 unsigned StackWidth = TFL->getStackWidth(MF);
1058 int End = getIndirectIndexEnd(MF);
1059
1060 if (End == -1)
1061 return;
1062
1063 for (int Index = getIndirectIndexBegin(MF); Index <= End; ++Index) {
1064 for (unsigned Chan = 0; Chan < StackWidth; ++Chan) {
1065 MCRegister Reg =
1066 R600::R600_TReg32RegClass.getRegister((4 * Index) + Chan);
1067 TRI.reserveRegisterTuples(Reserved, Reg);
1068 }
1069 }
1070}
1071
1073 return &R600::R600_TReg32_XRegClass;
1074}
1075
1076MachineInstrBuilder R600InstrInfo::buildIndirectWrite(MachineBasicBlock *MBB,
1078 unsigned ValueReg, unsigned Address,
1079 unsigned OffsetReg) const {
1080 return buildIndirectWrite(MBB, I, ValueReg, Address, OffsetReg, 0);
1081}
1082
1083MachineInstrBuilder R600InstrInfo::buildIndirectWrite(MachineBasicBlock *MBB,
1085 unsigned ValueReg, unsigned Address,
1086 unsigned OffsetReg,
1087 unsigned AddrChan) const {
1088 MCRegister AddrReg;
1089 switch (AddrChan) {
1090 default: llvm_unreachable("Invalid Channel");
1091 case 0: AddrReg = R600::R600_AddrRegClass.getRegister(Address); break;
1092 case 1: AddrReg = R600::R600_Addr_YRegClass.getRegister(Address); break;
1093 case 2: AddrReg = R600::R600_Addr_ZRegClass.getRegister(Address); break;
1094 case 3: AddrReg = R600::R600_Addr_WRegClass.getRegister(Address); break;
1095 }
1096 MachineInstr *MOVA = buildDefaultInstruction(*MBB, I, R600::MOVA_INT_eg,
1097 R600::AR_X, OffsetReg);
1098 setImmOperand(*MOVA, R600::OpName::write, 0);
1099
1101 AddrReg, ValueReg)
1102 .addReg(R600::AR_X,
1104 setImmOperand(*Mov, R600::OpName::dst_rel, 1);
1105 return Mov;
1106}
1107
1108MachineInstrBuilder R600InstrInfo::buildIndirectRead(MachineBasicBlock *MBB,
1110 unsigned ValueReg, unsigned Address,
1111 unsigned OffsetReg) const {
1112 return buildIndirectRead(MBB, I, ValueReg, Address, OffsetReg, 0);
1113}
1114
1115MachineInstrBuilder R600InstrInfo::buildIndirectRead(MachineBasicBlock *MBB,
1117 unsigned ValueReg, unsigned Address,
1118 unsigned OffsetReg,
1119 unsigned AddrChan) const {
1120 MCRegister AddrReg;
1121 switch (AddrChan) {
1122 default: llvm_unreachable("Invalid Channel");
1123 case 0: AddrReg = R600::R600_AddrRegClass.getRegister(Address); break;
1124 case 1: AddrReg = R600::R600_Addr_YRegClass.getRegister(Address); break;
1125 case 2: AddrReg = R600::R600_Addr_ZRegClass.getRegister(Address); break;
1126 case 3: AddrReg = R600::R600_Addr_WRegClass.getRegister(Address); break;
1127 }
1128 MachineInstr *MOVA = buildDefaultInstruction(*MBB, I, R600::MOVA_INT_eg,
1129 R600::AR_X,
1130 OffsetReg);
1131 setImmOperand(*MOVA, R600::OpName::write, 0);
1133 ValueReg,
1134 AddrReg)
1135 .addReg(R600::AR_X,
1137 setImmOperand(*Mov, R600::OpName::src0_rel, 1);
1138
1139 return Mov;
1140}
1141
1143 const MachineRegisterInfo &MRI = MF.getRegInfo();
1144 const MachineFrameInfo &MFI = MF.getFrameInfo();
1145 int Offset = -1;
1146
1147 if (MFI.getNumObjects() == 0) {
1148 return -1;
1149 }
1150
1151 if (MRI.livein_empty()) {
1152 return 0;
1153 }
1154
1155 const TargetRegisterClass *IndirectRC = getIndirectAddrRegClass();
1156 for (std::pair<MCRegister, Register> LI : MRI.liveins()) {
1157 Register Reg = LI.first;
1158 if (Reg.isVirtual() || !IndirectRC->contains(Reg))
1159 continue;
1160
1161 unsigned RegIndex;
1162 unsigned RegEnd;
1163 for (RegIndex = 0, RegEnd = IndirectRC->getNumRegs(); RegIndex != RegEnd;
1164 ++RegIndex) {
1165 if (IndirectRC->getRegister(RegIndex) == (unsigned)Reg)
1166 break;
1167 }
1168 Offset = std::max(Offset, (int)RegIndex);
1169 }
1170
1171 return Offset + 1;
1172}
1173
1175 int Offset = 0;
1176 const MachineFrameInfo &MFI = MF.getFrameInfo();
1177
1178 // Variable sized objects are not supported
1179 if (MFI.hasVarSizedObjects()) {
1180 return -1;
1181 }
1182
1183 if (MFI.getNumObjects() == 0) {
1184 return -1;
1185 }
1186
1187 const R600Subtarget &ST = MF.getSubtarget<R600Subtarget>();
1188 const R600FrameLowering *TFL = ST.getFrameLowering();
1189
1190 Register IgnoredFrameReg;
1191 Offset = TFL->getFrameIndexReference(MF, -1, IgnoredFrameReg).getFixed();
1192
1193 return getIndirectIndexBegin(MF) + Offset;
1194}
1195
1197 return 115;
1198}
1199
1202 unsigned Opcode,
1203 unsigned DstReg,
1204 unsigned Src0Reg,
1205 unsigned Src1Reg) const {
1206 MachineInstrBuilder MIB = BuildMI(MBB, I, MBB.findDebugLoc(I), get(Opcode),
1207 DstReg); // $dst
1208
1209 if (Src1Reg) {
1210 MIB.addImm(0) // $update_exec_mask
1211 .addImm(0); // $update_predicate
1212 }
1213 MIB.addImm(1) // $write
1214 .addImm(0) // $omod
1215 .addImm(0) // $dst_rel
1216 .addImm(0) // $dst_clamp
1217 .addReg(Src0Reg) // $src0
1218 .addImm(0) // $src0_neg
1219 .addImm(0) // $src0_rel
1220 .addImm(0) // $src0_abs
1221 .addImm(-1); // $src0_sel
1222
1223 if (Src1Reg) {
1224 MIB.addReg(Src1Reg) // $src1
1225 .addImm(0) // $src1_neg
1226 .addImm(0) // $src1_rel
1227 .addImm(0) // $src1_abs
1228 .addImm(-1); // $src1_sel
1229 }
1230
1231 //XXX: The r600g finalizer expects this to be 1, once we've moved the
1232 //scheduling to the backend, we can change the default to 0.
1233 MIB.addImm(1) // $last
1234 .addReg(R600::PRED_SEL_OFF) // $pred_sel
1235 .addImm(0) // $literal
1236 .addImm(0); // $bank_swizzle
1237
1238 return MIB;
1239}
1240
1241#define OPERAND_CASE(Label) \
1242 case Label: { \
1243 static const R600::OpName Ops[] = {Label##_X, Label##_Y, Label##_Z, \
1244 Label##_W}; \
1245 return Ops[Slot]; \
1246 }
1247
1248static R600::OpName getSlotedOps(R600::OpName Op, unsigned Slot) {
1249 switch (Op) {
1250 OPERAND_CASE(R600::OpName::update_exec_mask)
1251 OPERAND_CASE(R600::OpName::update_pred)
1252 OPERAND_CASE(R600::OpName::write)
1253 OPERAND_CASE(R600::OpName::omod)
1254 OPERAND_CASE(R600::OpName::dst_rel)
1255 OPERAND_CASE(R600::OpName::clamp)
1256 OPERAND_CASE(R600::OpName::src0)
1257 OPERAND_CASE(R600::OpName::src0_neg)
1258 OPERAND_CASE(R600::OpName::src0_rel)
1259 OPERAND_CASE(R600::OpName::src0_abs)
1260 OPERAND_CASE(R600::OpName::src0_sel)
1261 OPERAND_CASE(R600::OpName::src1)
1262 OPERAND_CASE(R600::OpName::src1_neg)
1263 OPERAND_CASE(R600::OpName::src1_rel)
1264 OPERAND_CASE(R600::OpName::src1_abs)
1265 OPERAND_CASE(R600::OpName::src1_sel)
1266 OPERAND_CASE(R600::OpName::pred_sel)
1267 default:
1268 llvm_unreachable("Wrong Operand");
1269 }
1270}
1271
1272#undef OPERAND_CASE
1273
1275 MachineBasicBlock &MBB, MachineInstr *MI, unsigned Slot, unsigned DstReg)
1276 const {
1277 assert (MI->getOpcode() == R600::DOT_4 && "Not Implemented");
1278 unsigned Opcode;
1279 if (ST.getGeneration() <= AMDGPUSubtarget::R700)
1280 Opcode = R600::DOT4_r600;
1281 else
1282 Opcode = R600::DOT4_eg;
1284 MachineOperand &Src0 = MI->getOperand(
1285 getOperandIdx(MI->getOpcode(), getSlotedOps(R600::OpName::src0, Slot)));
1286 MachineOperand &Src1 = MI->getOperand(
1287 getOperandIdx(MI->getOpcode(), getSlotedOps(R600::OpName::src1, Slot)));
1289 MBB, I, Opcode, DstReg, Src0.getReg(), Src1.getReg());
1290 static const R600::OpName Operands[14] = {
1291 R600::OpName::update_exec_mask,
1292 R600::OpName::update_pred,
1293 R600::OpName::write,
1294 R600::OpName::omod,
1295 R600::OpName::dst_rel,
1296 R600::OpName::clamp,
1297 R600::OpName::src0_neg,
1298 R600::OpName::src0_rel,
1299 R600::OpName::src0_abs,
1300 R600::OpName::src0_sel,
1301 R600::OpName::src1_neg,
1302 R600::OpName::src1_rel,
1303 R600::OpName::src1_abs,
1304 R600::OpName::src1_sel,
1305 };
1306
1307 MachineOperand &MO = MI->getOperand(getOperandIdx(MI->getOpcode(),
1308 getSlotedOps(R600::OpName::pred_sel, Slot)));
1309 MIB->getOperand(getOperandIdx(Opcode, R600::OpName::pred_sel))
1310 .setReg(MO.getReg());
1311
1312 for (R600::OpName Operand : Operands) {
1313 MachineOperand &MO = MI->getOperand(
1314 getOperandIdx(MI->getOpcode(), getSlotedOps(Operand, Slot)));
1315 assert (MO.isImm());
1316 setImmOperand(*MIB, Operand, MO.getImm());
1317 }
1318 MIB->getOperand(20).setImm(0);
1319 return MIB;
1320}
1321
1324 unsigned DstReg,
1325 uint64_t Imm) const {
1326 MachineInstr *MovImm = buildDefaultInstruction(BB, I, R600::MOV, DstReg,
1327 R600::ALU_LITERAL_X);
1328 setImmOperand(*MovImm, R600::OpName::literal, Imm);
1329 return MovImm;
1330}
1331
1334 unsigned DstReg, unsigned SrcReg) const {
1335 return buildDefaultInstruction(*MBB, I, R600::MOV, DstReg, SrcReg);
1336}
1337
1339 R600::OpName Op) const {
1340 return getOperandIdx(MI.getOpcode(), Op);
1341}
1342
1343int R600InstrInfo::getOperandIdx(unsigned Opcode, R600::OpName Op) const {
1344 return R600::getNamedOperandIdx(Opcode, Op);
1345}
1346
1348 int64_t Imm) const {
1349 int Idx = getOperandIdx(MI, Op);
1350 assert(Idx != -1 && "Operand not supported for this instruction.");
1351 assert(MI.getOperand(Idx).isImm());
1352 MI.getOperand(Idx).setImm(Imm);
1353}
1354
1355//===----------------------------------------------------------------------===//
1356// Instruction flag getters/setters
1357//===----------------------------------------------------------------------===//
1358
1360 unsigned Flag) const {
1361 unsigned TargetFlags = get(MI.getOpcode()).TSFlags;
1362 int FlagIndex = 0;
1363 if (Flag != 0) {
1364 // If we pass something other than the default value of Flag to this
1365 // function, it means we are want to set a flag on an instruction
1366 // that uses native encoding.
1367 assert(HAS_NATIVE_OPERANDS(TargetFlags));
1368 bool IsOP3 = (TargetFlags & R600_InstFlag::OP3) == R600_InstFlag::OP3;
1369 switch (Flag) {
1370 case MO_FLAG_CLAMP:
1371 FlagIndex = getOperandIdx(MI, R600::OpName::clamp);
1372 break;
1373 case MO_FLAG_MASK:
1374 FlagIndex = getOperandIdx(MI, R600::OpName::write);
1375 break;
1376 case MO_FLAG_NOT_LAST:
1377 case MO_FLAG_LAST:
1378 FlagIndex = getOperandIdx(MI, R600::OpName::last);
1379 break;
1380 case MO_FLAG_NEG:
1381 switch (SrcIdx) {
1382 case 0:
1383 FlagIndex = getOperandIdx(MI, R600::OpName::src0_neg);
1384 break;
1385 case 1:
1386 FlagIndex = getOperandIdx(MI, R600::OpName::src1_neg);
1387 break;
1388 case 2:
1389 FlagIndex = getOperandIdx(MI, R600::OpName::src2_neg);
1390 break;
1391 }
1392 break;
1393
1394 case MO_FLAG_ABS:
1395 assert(!IsOP3 && "Cannot set absolute value modifier for OP3 "
1396 "instructions.");
1397 (void)IsOP3;
1398 switch (SrcIdx) {
1399 case 0:
1400 FlagIndex = getOperandIdx(MI, R600::OpName::src0_abs);
1401 break;
1402 case 1:
1403 FlagIndex = getOperandIdx(MI, R600::OpName::src1_abs);
1404 break;
1405 }
1406 break;
1407
1408 default:
1409 FlagIndex = -1;
1410 break;
1411 }
1412 assert(FlagIndex != -1 && "Flag not supported for this instruction");
1413 } else {
1414 FlagIndex = GET_FLAG_OPERAND_IDX(TargetFlags);
1415 assert(FlagIndex != 0 &&
1416 "Instruction flags not supported for this instruction");
1417 }
1418
1419 MachineOperand &FlagOp = MI.getOperand(FlagIndex);
1420 assert(FlagOp.isImm());
1421 return FlagOp;
1422}
1423
1425 unsigned Flag) const {
1426 unsigned TargetFlags = get(MI.getOpcode()).TSFlags;
1427 if (Flag == 0) {
1428 return;
1429 }
1430 if (HAS_NATIVE_OPERANDS(TargetFlags)) {
1431 MachineOperand &FlagOp = getFlagOp(MI, SrcIdx, Flag);
1432 if (Flag == MO_FLAG_NOT_LAST) {
1433 clearFlag(MI, SrcIdx, MO_FLAG_LAST);
1434 } else if (Flag == MO_FLAG_MASK) {
1435 clearFlag(MI, SrcIdx, Flag);
1436 } else {
1437 FlagOp.setImm(1);
1438 }
1439 } else {
1440 MachineOperand &FlagOp = getFlagOp(MI, SrcIdx);
1441 FlagOp.setImm(FlagOp.getImm() | (Flag << (NUM_MO_FLAGS * SrcIdx)));
1442 }
1443}
1444
1446 unsigned Flag) const {
1447 unsigned TargetFlags = get(MI.getOpcode()).TSFlags;
1448 if (HAS_NATIVE_OPERANDS(TargetFlags)) {
1449 MachineOperand &FlagOp = getFlagOp(MI, SrcIdx, Flag);
1450 FlagOp.setImm(0);
1451 } else {
1452 MachineOperand &FlagOp = getFlagOp(MI);
1453 unsigned InstFlags = FlagOp.getImm();
1454 InstFlags &= ~(Flag << (NUM_MO_FLAGS * SrcIdx));
1455 FlagOp.setImm(InstFlags);
1456 }
1457}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
uint64_t Imm
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition MD5.cpp:57
Register Reg
Register const TargetRegisterInfo * TRI
static MCRegister getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
uint64_t IntrinsicInst * II
#define GET_REG_INDEX(reg)
Definition R600Defines.h:57
#define NUM_MO_FLAGS
Definition R600Defines.h:21
#define MO_FLAG_CLAMP
Definition R600Defines.h:14
#define HAS_NATIVE_OPERANDS(Flags)
Definition R600Defines.h:50
#define IS_VTX(desc)
Definition R600Defines.h:59
#define MO_FLAG_NEG
Definition R600Defines.h:15
#define MO_FLAG_NOT_LAST
Definition R600Defines.h:19
#define MO_FLAG_ABS
Definition R600Defines.h:16
#define MO_FLAG_MASK
Definition R600Defines.h:17
#define MO_FLAG_LAST
Definition R600Defines.h:20
#define GET_FLAG_OPERAND_IDX(Flags)
Helper for getting the operand index for the instruction flags operand.
Definition R600Defines.h:25
#define IS_TEX(desc)
Definition R600Defines.h:60
#define MO_FLAG_PUSH
Definition R600Defines.h:18
static MachineInstr * findFirstPredicateSetterFrom(MachineBasicBlock &MBB, MachineBasicBlock::iterator I)
static R600::OpName getSlotedOps(R600::OpName Op, unsigned Slot)
static bool isBranch(unsigned Opcode)
static MachineBasicBlock::iterator FindLastAluClause(MachineBasicBlock &MBB)
#define OPERAND_CASE(Label)
static std::vector< std::pair< int, unsigned > > Swizzle(std::vector< std::pair< int, unsigned > > Src, R600InstrInfo::BankSwizzle Swz)
static unsigned getTransSwizzle(R600InstrInfo::BankSwizzle Swz, unsigned Op)
static bool isConstCompatible(R600InstrInfo::BankSwizzle TransSwz, const std::vector< std::pair< int, unsigned > > &TransOps, unsigned ConstCount)
Instructions in Trans slot can't read gpr at cycle 0 if they also read a const, and can't read a gpr ...
static bool isPredicateSetter(unsigned Opcode)
static bool NextPossibleSolution(std::vector< R600InstrInfo::BankSwizzle > &SwzCandidate, unsigned Idx)
Given a swizzle sequence SwzCandidate and an index Idx, returns the next (in lexicographic term) swiz...
static bool isJump(unsigned Opcode)
Interface definition for R600InstrInfo.
Provides R600 specific target descriptions.
AMDGPU R600 specific subclass of TargetSubtarget.
SmallVector< MachineOperand, 4 > Cond
MachineRegisterInfo & MRI
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
SI Fold Operands
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
Definition Value.cpp:479
unsigned getStackWidth(const MachineFunction &MF) const
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
A debug info location.
Definition DebugLoc.h:126
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
Definition DenseMap.h:757
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition Function.h:273
Itinerary data supplied by a subtarget to be used by a target.
MCRegister getRegister(unsigned i) const
getRegister - Return the specified register in the class.
unsigned getNumRegs() const
getNumRegs - Return the number of registers in this class.
bool contains(MCRegister Reg) const
contains - Return true if the specified register is included in this register class.
Wrapper class representing physical registers. Should be passed by value.
Definition MCRegister.h:41
MachineInstrBundleIterator< const MachineInstr > const_iterator
MachineInstrBundleIterator< MachineInstr, true > reverse_iterator
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
unsigned getNumObjects() const
Return the number of objects.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineInstrBuilder & addReg(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
MachineOperand class - Representation of each machine instruction operand.
void setImm(int64_t immVal)
int64_t getImm() const
MachineBasicBlock * getMBB() const
LLVM_ABI void setReg(Register Reg)
Change the register this operand corresponds to.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
void setIsKill(bool Val=true)
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
Register getReg() const
getReg - Returns the register number.
static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isEarlyClobber=false, unsigned SubReg=0, bool isDebug=false, bool isInternalRead=false, bool isRenamable=false)
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
bool usesVertexCache(unsigned Opcode) const
MachineInstrBuilder buildDefaultInstruction(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, unsigned Opcode, unsigned DstReg, unsigned Src0Reg, unsigned Src1Reg=0) const
buildDefaultInstruction - This function returns a MachineInstr with all the instruction modifiers ini...
bool reverseBranchCondition(SmallVectorImpl< MachineOperand > &Cond) const override
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
void addFlag(MachineInstr &MI, unsigned SrcIdx, unsigned Flag) const
Add one of the MO_FLAG* flags to the operand at SrcIdx.
bool usesAddressRegister(MachineInstr &MI) const
unsigned calculateIndirectAddress(unsigned RegIndex, unsigned Channel) const
Calculate the "Indirect Address" for the given RegIndex and Channel.
bool hasInstrModifiers(unsigned Opcode) const
R600InstrInfo(const R600Subtarget &)
bool isMov(unsigned Opcode) const
bool isRegisterLoad(const MachineInstr &MI) const
int getIndirectIndexBegin(const MachineFunction &MF) const
bool isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles, BranchProbability Probability) const override
bool usesTextureCache(unsigned Opcode) const
unsigned isLegalUpTo(const std::vector< std::vector< std::pair< int, unsigned > > > &IGSrcs, const std::vector< R600InstrInfo::BankSwizzle > &Swz, const std::vector< std::pair< int, unsigned > > &TransSrcs, R600InstrInfo::BankSwizzle TransSwz) const
returns how many MIs (whose inputs are represented by IGSrcs) can be packed in the same Instruction G...
unsigned int getInstrLatency(const InstrItineraryData *ItinData, const MachineInstr &MI, unsigned *PredCost=nullptr) const override
const TargetRegisterClass * getIndirectAddrRegClass() const
void clearFlag(MachineInstr &MI, unsigned SrcIdx, unsigned Flag) const
Clear the specified flag on the instruction.
MachineInstr * buildMovImm(MachineBasicBlock &BB, MachineBasicBlock::iterator I, unsigned DstReg, uint64_t Imm) const
bool definesAddressRegister(MachineInstr &MI) const
unsigned getMaxAlusPerClause() const
bool PredicateInstruction(MachineInstr &MI, ArrayRef< MachineOperand > Pred) const override
int getOperandIdx(const MachineInstr &MI, R600::OpName Op) const
Get the index of Op in the MachineInstr.
bool isLegalToSplitMBBAt(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const override
bool canBeConsideredALU(const MachineInstr &MI) const
bool isProfitableToUnpredicate(MachineBasicBlock &TMBB, MachineBasicBlock &FMBB) const override
bool fitsConstReadLimitations(const std::vector< MachineInstr * > &) const
An instruction group can only access 2 channel pair (either [XY] or [ZW]) from KCache bank on R700+.
bool isVector(const MachineInstr &MI) const
Vector instructions are instructions that must fill all instruction slots within an instruction group...
unsigned removeBranch(MachineBasicBlock &MBB, int *BytesRemoved=nullptr) const override
bool mustBeLastInClause(unsigned Opcode) const
unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB, ArrayRef< MachineOperand > Cond, const DebugLoc &DL, int *BytesAdded=nullptr) const override
int getIndirectIndexEnd(const MachineFunction &MF) const
bool isTransOnly(unsigned Opcode) const
DFAPacketizer * CreateTargetScheduleState(const TargetSubtargetInfo &) const override
bool isReductionOp(unsigned opcode) const
bool isRegisterStore(const MachineInstr &MI) const
bool isCubeOp(unsigned opcode) const
bool isLDSInstr(unsigned Opcode) const
void reserveIndirectRegisters(BitVector &Reserved, const MachineFunction &MF, const R600RegisterInfo &TRI) const
Reserve the registers that may be accessed using indirect addressing.
void setImmOperand(MachineInstr &MI, R600::OpName Op, int64_t Imm) const
Helper function for setting instruction flag values.
bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles, unsigned ExtraPredCycles, BranchProbability Probability) const override
bool isPredicable(const MachineInstr &MI) const override
bool isPredicated(const MachineInstr &MI) const override
bool expandPostRAPseudo(MachineInstr &MI) const override
bool isLDSRetInstr(unsigned Opcode) const
int getSelIdx(unsigned Opcode, unsigned SrcIdx) const
MachineOperand & getFlagOp(MachineInstr &MI, unsigned SrcIdx=0, unsigned Flag=0) const
unsigned int getPredicationCost(const MachineInstr &) const override
MachineInstr * buildSlotOfVectorInstruction(MachineBasicBlock &MBB, MachineInstr *MI, unsigned Slot, unsigned DstReg) const
bool readsLDSSrcReg(const MachineInstr &MI) const
bool FindSwizzleForVectorSlot(const std::vector< std::vector< std::pair< int, unsigned > > > &IGSrcs, std::vector< R600InstrInfo::BankSwizzle > &SwzCandidate, const std::vector< std::pair< int, unsigned > > &TransSrcs, R600InstrInfo::BankSwizzle TransSwz) const
Enumerate all possible Swizzle sequence to find one that can meet all read port requirements.
bool fitsReadPortLimitations(const std::vector< MachineInstr * > &MIs, const DenseMap< unsigned, unsigned > &PV, std::vector< BankSwizzle > &BS, bool isLastAluTrans) const
Given the order VEC_012 < VEC_021 < VEC_120 < VEC_102 < VEC_201 < VEC_210 returns true and the first ...
bool ClobbersPredicate(MachineInstr &MI, std::vector< MachineOperand > &Pred, bool SkipDead) const override
bool isALUInstr(unsigned Opcode) const
void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL, Register DestReg, Register SrcReg, bool KillSrc, bool RenamableDest=false, bool RenamableSrc=false) const override
bool isVectorOnly(unsigned Opcode) const
bool isExport(unsigned Opcode) const
SmallVector< std::pair< MachineOperand *, int64_t >, 3 > getSrcs(MachineInstr &MI) const
MachineInstr * buildMovInstr(MachineBasicBlock *MBB, MachineBasicBlock::iterator I, unsigned DstReg, unsigned SrcReg) const
Wrapper class representing virtual and physical registers.
Definition Register.h:20
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition SmallSet.h:134
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition SmallSet.h:184
size_type size() const
Definition SmallSet.h:171
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
virtual bool isPredicable(const MachineInstr &MI) const
Return true if the specified instruction can be predicated.
TargetSubtargetInfo - Generic base class for all target subtargets.
virtual const InstrItineraryData * getInstrItineraryData() const
getInstrItineraryData - Returns instruction itinerary data for the target or specific subtarget.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_READNONE constexpr bool isCompute(CallingConv::ID CC)
This is an optimization pass for GlobalISel generic memory operations.
@ Offset
Definition DWP.cpp:577
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
@ Implicit
Not emitted register (e.g. carry, or temporary result).
@ Kill
The last use of a register.
@ Define
Register definition.
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
DWARFExpression::Operation Op
@ End
Run the machine verifier once, at the end of the pipeline.
Definition CodeGen.h:320
MCRegisterClass TargetRegisterClass
Definition FastISel.h:58
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition BitVector.h:881
unsigned getHWRegChan(unsigned reg) const
get the HW encoding for a register's channel.
static unsigned getSubRegFromChannel(unsigned Channel)