1 //===-- SIInstrInfo.h - SI Instruction Info Interface -----------*- 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 //===----------------------------------------------------------------------===//
11 /// \brief Interface definition for SIInstrInfo.
13 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_LIB_TARGET_AMDGPU_SIINSTRINFO_H
17 #define LLVM_LIB_TARGET_AMDGPU_SIINSTRINFO_H
19 #include "AMDGPUInstrInfo.h"
20 #include "SIDefines.h"
21 #include "SIRegisterInfo.h"
25 class SIInstrInfo final : public AMDGPUInstrInfo {
27 const SIRegisterInfo RI;
28 const SISubtarget &ST;
30 // The the inverse predicate should have the negative value.
31 enum BranchPredicate {
41 static unsigned getBranchOpcode(BranchPredicate Cond);
42 static BranchPredicate getBranchPredicate(unsigned Opcode);
44 unsigned buildExtractSubReg(MachineBasicBlock::iterator MI,
45 MachineRegisterInfo &MRI,
46 MachineOperand &SuperReg,
47 const TargetRegisterClass *SuperRC,
49 const TargetRegisterClass *SubRC) const;
50 MachineOperand buildExtractSubRegOrImm(MachineBasicBlock::iterator MI,
51 MachineRegisterInfo &MRI,
52 MachineOperand &SuperReg,
53 const TargetRegisterClass *SuperRC,
55 const TargetRegisterClass *SubRC) const;
57 void swapOperands(MachineInstr &Inst) const;
59 void lowerScalarAbs(SmallVectorImpl<MachineInstr *> &Worklist,
60 MachineInstr &Inst) const;
62 void splitScalar64BitUnaryOp(SmallVectorImpl<MachineInstr *> &Worklist,
63 MachineInstr &Inst, unsigned Opcode) const;
65 void splitScalar64BitBinaryOp(SmallVectorImpl<MachineInstr *> &Worklist,
66 MachineInstr &Inst, unsigned Opcode) const;
68 void splitScalar64BitBCNT(SmallVectorImpl<MachineInstr *> &Worklist,
69 MachineInstr &Inst) const;
70 void splitScalar64BitBFE(SmallVectorImpl<MachineInstr *> &Worklist,
71 MachineInstr &Inst) const;
73 void addUsersToMoveToVALUWorklist(
74 unsigned Reg, MachineRegisterInfo &MRI,
75 SmallVectorImpl<MachineInstr *> &Worklist) const;
78 addSCCDefUsersToVALUWorklist(MachineInstr &SCCDefInst,
79 SmallVectorImpl<MachineInstr *> &Worklist) const;
81 const TargetRegisterClass *
82 getDestEquivalentVGPRClass(const MachineInstr &Inst) const;
84 bool checkInstOffsetsDoNotOverlap(MachineInstr &MIa, MachineInstr &MIb) const;
86 unsigned findUsedSGPR(const MachineInstr &MI, int OpIndices[3]) const;
89 bool swapSourceModifiers(MachineInstr &MI,
90 MachineOperand &Src0, unsigned Src0OpName,
91 MachineOperand &Src1, unsigned Src1OpName) const;
93 MachineInstr *commuteInstructionImpl(MachineInstr &MI, bool NewMI,
95 unsigned OpIdx1) const override;
99 enum TargetOperandFlags {
101 // MO_GOTPCREL -> symbol@GOTPCREL -> R_AMDGPU_GOTPCREL.
103 // MO_GOTPCREL32_LO -> symbol@gotpcrel32@lo -> R_AMDGPU_GOTPCREL32_LO.
105 MO_GOTPCREL32_LO = 2,
106 // MO_GOTPCREL32_HI -> symbol@gotpcrel32@hi -> R_AMDGPU_GOTPCREL32_HI.
107 MO_GOTPCREL32_HI = 3,
108 // MO_REL32_LO -> symbol@rel32@lo -> R_AMDGPU_REL32_LO.
111 // MO_REL32_HI -> symbol@rel32@hi -> R_AMDGPU_REL32_HI.
115 explicit SIInstrInfo(const SISubtarget &);
117 const SIRegisterInfo &getRegisterInfo() const {
121 bool isReallyTriviallyReMaterializable(const MachineInstr &MI,
122 AliasAnalysis *AA) const override;
124 bool areLoadsFromSameBasePtr(SDNode *Load1, SDNode *Load2,
126 int64_t &Offset2) const override;
128 bool getMemOpBaseRegImmOfs(MachineInstr &LdSt, unsigned &BaseReg,
130 const TargetRegisterInfo *TRI) const final;
132 bool shouldClusterMemOps(MachineInstr &FirstLdSt, MachineInstr &SecondLdSt,
133 unsigned NumLoads) const final;
135 void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
136 const DebugLoc &DL, unsigned DestReg, unsigned SrcReg,
137 bool KillSrc) const override;
139 unsigned calculateLDSSpillAddress(MachineBasicBlock &MBB, MachineInstr &MI,
140 RegScavenger *RS, unsigned TmpReg,
141 unsigned Offset, unsigned Size) const;
143 void storeRegToStackSlot(MachineBasicBlock &MBB,
144 MachineBasicBlock::iterator MI, unsigned SrcReg,
145 bool isKill, int FrameIndex,
146 const TargetRegisterClass *RC,
147 const TargetRegisterInfo *TRI) const override;
149 void loadRegFromStackSlot(MachineBasicBlock &MBB,
150 MachineBasicBlock::iterator MI, unsigned DestReg,
151 int FrameIndex, const TargetRegisterClass *RC,
152 const TargetRegisterInfo *TRI) const override;
154 bool expandPostRAPseudo(MachineInstr &MI) const override;
156 // \brief Returns an opcode that can be used to move a value to a \p DstRC
157 // register. If there is no hardware instruction that can store to \p
158 // DstRC, then AMDGPU::COPY is returned.
159 unsigned getMovOpcode(const TargetRegisterClass *DstRC) const;
162 int commuteOpcode(unsigned Opc) const;
165 inline int commuteOpcode(const MachineInstr &MI) const {
166 return commuteOpcode(MI.getOpcode());
169 bool findCommutedOpIndices(MachineInstr &MI, unsigned &SrcOpIdx1,
170 unsigned &SrcOpIdx2) const override;
172 bool isBranchOffsetInRange(unsigned BranchOpc,
173 int64_t BrOffset) const override;
175 MachineBasicBlock *getBranchDestBlock(const MachineInstr &MI) const override;
177 unsigned insertIndirectBranch(MachineBasicBlock &MBB,
178 MachineBasicBlock &NewDestBB,
181 RegScavenger *RS = nullptr) const override;
183 bool analyzeBranchImpl(MachineBasicBlock &MBB,
184 MachineBasicBlock::iterator I,
185 MachineBasicBlock *&TBB,
186 MachineBasicBlock *&FBB,
187 SmallVectorImpl<MachineOperand> &Cond,
188 bool AllowModify) const;
190 bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
191 MachineBasicBlock *&FBB,
192 SmallVectorImpl<MachineOperand> &Cond,
193 bool AllowModify) const override;
195 unsigned removeBranch(MachineBasicBlock &MBB,
196 int *BytesRemoved = nullptr) const override;
198 unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
199 MachineBasicBlock *FBB, ArrayRef<MachineOperand> Cond,
201 int *BytesAdded = nullptr) const override;
203 bool reverseBranchCondition(
204 SmallVectorImpl<MachineOperand> &Cond) const override;
207 areMemAccessesTriviallyDisjoint(MachineInstr &MIa, MachineInstr &MIb,
208 AliasAnalysis *AA = nullptr) const override;
210 bool FoldImmediate(MachineInstr &UseMI, MachineInstr &DefMI, unsigned Reg,
211 MachineRegisterInfo *MRI) const final;
213 unsigned getMachineCSELookAheadLimit() const override { return 500; }
215 MachineInstr *convertToThreeAddress(MachineFunction::iterator &MBB,
217 LiveVariables *LV) const override;
219 bool isSchedulingBoundary(const MachineInstr &MI,
220 const MachineBasicBlock *MBB,
221 const MachineFunction &MF) const override;
223 static bool isSALU(const MachineInstr &MI) {
224 return MI.getDesc().TSFlags & SIInstrFlags::SALU;
227 bool isSALU(uint16_t Opcode) const {
228 return get(Opcode).TSFlags & SIInstrFlags::SALU;
231 static bool isVALU(const MachineInstr &MI) {
232 return MI.getDesc().TSFlags & SIInstrFlags::VALU;
235 bool isVALU(uint16_t Opcode) const {
236 return get(Opcode).TSFlags & SIInstrFlags::VALU;
239 static bool isVMEM(const MachineInstr &MI) {
240 return isMUBUF(MI) || isMTBUF(MI) || isMIMG(MI);
243 bool isVMEM(uint16_t Opcode) const {
244 return isMUBUF(Opcode) || isMTBUF(Opcode) || isMIMG(Opcode);
247 static bool isSOP1(const MachineInstr &MI) {
248 return MI.getDesc().TSFlags & SIInstrFlags::SOP1;
251 bool isSOP1(uint16_t Opcode) const {
252 return get(Opcode).TSFlags & SIInstrFlags::SOP1;
255 static bool isSOP2(const MachineInstr &MI) {
256 return MI.getDesc().TSFlags & SIInstrFlags::SOP2;
259 bool isSOP2(uint16_t Opcode) const {
260 return get(Opcode).TSFlags & SIInstrFlags::SOP2;
263 static bool isSOPC(const MachineInstr &MI) {
264 return MI.getDesc().TSFlags & SIInstrFlags::SOPC;
267 bool isSOPC(uint16_t Opcode) const {
268 return get(Opcode).TSFlags & SIInstrFlags::SOPC;
271 static bool isSOPK(const MachineInstr &MI) {
272 return MI.getDesc().TSFlags & SIInstrFlags::SOPK;
275 bool isSOPK(uint16_t Opcode) const {
276 return get(Opcode).TSFlags & SIInstrFlags::SOPK;
279 static bool isSOPP(const MachineInstr &MI) {
280 return MI.getDesc().TSFlags & SIInstrFlags::SOPP;
283 bool isSOPP(uint16_t Opcode) const {
284 return get(Opcode).TSFlags & SIInstrFlags::SOPP;
287 static bool isVOP1(const MachineInstr &MI) {
288 return MI.getDesc().TSFlags & SIInstrFlags::VOP1;
291 bool isVOP1(uint16_t Opcode) const {
292 return get(Opcode).TSFlags & SIInstrFlags::VOP1;
295 static bool isVOP2(const MachineInstr &MI) {
296 return MI.getDesc().TSFlags & SIInstrFlags::VOP2;
299 bool isVOP2(uint16_t Opcode) const {
300 return get(Opcode).TSFlags & SIInstrFlags::VOP2;
303 static bool isVOP3(const MachineInstr &MI) {
304 return MI.getDesc().TSFlags & SIInstrFlags::VOP3;
307 bool isVOP3(uint16_t Opcode) const {
308 return get(Opcode).TSFlags & SIInstrFlags::VOP3;
311 static bool isVOPC(const MachineInstr &MI) {
312 return MI.getDesc().TSFlags & SIInstrFlags::VOPC;
315 bool isVOPC(uint16_t Opcode) const {
316 return get(Opcode).TSFlags & SIInstrFlags::VOPC;
319 static bool isMUBUF(const MachineInstr &MI) {
320 return MI.getDesc().TSFlags & SIInstrFlags::MUBUF;
323 bool isMUBUF(uint16_t Opcode) const {
324 return get(Opcode).TSFlags & SIInstrFlags::MUBUF;
327 static bool isMTBUF(const MachineInstr &MI) {
328 return MI.getDesc().TSFlags & SIInstrFlags::MTBUF;
331 bool isMTBUF(uint16_t Opcode) const {
332 return get(Opcode).TSFlags & SIInstrFlags::MTBUF;
335 static bool isSMRD(const MachineInstr &MI) {
336 return MI.getDesc().TSFlags & SIInstrFlags::SMRD;
339 bool isSMRD(uint16_t Opcode) const {
340 return get(Opcode).TSFlags & SIInstrFlags::SMRD;
343 static bool isDS(const MachineInstr &MI) {
344 return MI.getDesc().TSFlags & SIInstrFlags::DS;
347 bool isDS(uint16_t Opcode) const {
348 return get(Opcode).TSFlags & SIInstrFlags::DS;
351 static bool isMIMG(const MachineInstr &MI) {
352 return MI.getDesc().TSFlags & SIInstrFlags::MIMG;
355 bool isMIMG(uint16_t Opcode) const {
356 return get(Opcode).TSFlags & SIInstrFlags::MIMG;
359 static bool isGather4(const MachineInstr &MI) {
360 return MI.getDesc().TSFlags & SIInstrFlags::Gather4;
363 bool isGather4(uint16_t Opcode) const {
364 return get(Opcode).TSFlags & SIInstrFlags::Gather4;
367 static bool isFLAT(const MachineInstr &MI) {
368 return MI.getDesc().TSFlags & SIInstrFlags::FLAT;
371 bool isFLAT(uint16_t Opcode) const {
372 return get(Opcode).TSFlags & SIInstrFlags::FLAT;
375 static bool isWQM(const MachineInstr &MI) {
376 return MI.getDesc().TSFlags & SIInstrFlags::WQM;
379 bool isWQM(uint16_t Opcode) const {
380 return get(Opcode).TSFlags & SIInstrFlags::WQM;
383 static bool isDisableWQM(const MachineInstr &MI) {
384 return MI.getDesc().TSFlags & SIInstrFlags::DisableWQM;
387 bool isDisableWQM(uint16_t Opcode) const {
388 return get(Opcode).TSFlags & SIInstrFlags::DisableWQM;
391 static bool isVGPRSpill(const MachineInstr &MI) {
392 return MI.getDesc().TSFlags & SIInstrFlags::VGPRSpill;
395 bool isVGPRSpill(uint16_t Opcode) const {
396 return get(Opcode).TSFlags & SIInstrFlags::VGPRSpill;
399 static bool isSGPRSpill(const MachineInstr &MI) {
400 return MI.getDesc().TSFlags & SIInstrFlags::SGPRSpill;
403 bool isSGPRSpill(uint16_t Opcode) const {
404 return get(Opcode).TSFlags & SIInstrFlags::SGPRSpill;
407 static bool isDPP(const MachineInstr &MI) {
408 return MI.getDesc().TSFlags & SIInstrFlags::DPP;
411 bool isDPP(uint16_t Opcode) const {
412 return get(Opcode).TSFlags & SIInstrFlags::DPP;
415 static bool isScalarUnit(const MachineInstr &MI) {
416 return MI.getDesc().TSFlags & (SIInstrFlags::SALU | SIInstrFlags::SMRD);
419 static bool usesVM_CNT(const MachineInstr &MI) {
420 return MI.getDesc().TSFlags & SIInstrFlags::VM_CNT;
423 static bool sopkIsZext(const MachineInstr &MI) {
424 return MI.getDesc().TSFlags & SIInstrFlags::SOPK_ZEXT;
427 bool sopkIsZext(uint16_t Opcode) const {
428 return get(Opcode).TSFlags & SIInstrFlags::SOPK_ZEXT;
431 /// \returns true if this is an s_store_dword* instruction. This is more
432 /// specific than than isSMEM && mayStore.
433 static bool isScalarStore(const MachineInstr &MI) {
434 return MI.getDesc().TSFlags & SIInstrFlags::SCALAR_STORE;
437 bool isScalarStore(uint16_t Opcode) const {
438 return get(Opcode).TSFlags & SIInstrFlags::SCALAR_STORE;
441 static bool isFixedSize(const MachineInstr &MI) {
442 return MI.getDesc().TSFlags & SIInstrFlags::FIXED_SIZE;
445 bool isFixedSize(uint16_t Opcode) const {
446 return get(Opcode).TSFlags & SIInstrFlags::FIXED_SIZE;
449 bool isVGPRCopy(const MachineInstr &MI) const {
451 unsigned Dest = MI.getOperand(0).getReg();
452 const MachineFunction &MF = *MI.getParent()->getParent();
453 const MachineRegisterInfo &MRI = MF.getRegInfo();
454 return !RI.isSGPRReg(MRI, Dest);
457 bool isInlineConstant(const APInt &Imm) const;
458 bool isInlineConstant(const MachineOperand &MO, unsigned OpSize) const;
459 bool isLiteralConstant(const MachineOperand &MO, unsigned OpSize) const;
461 // Returns true if this operand could potentially require a 32-bit literal
462 // operand, but not necessarily. A FrameIndex for example could resolve to an
463 // inline immediate value that will not require an additional 4-bytes; this
464 // assumes that it will.
465 bool isLiteralConstantLike(const MachineOperand &MO, unsigned OpSize) const;
467 bool isImmOperandLegal(const MachineInstr &MI, unsigned OpNo,
468 const MachineOperand &MO) const;
470 /// \brief Return true if this 64-bit VALU instruction has a 32-bit encoding.
471 /// This function will return false if you pass it a 32-bit instruction.
472 bool hasVALU32BitEncoding(unsigned Opcode) const;
474 /// \brief Returns true if this operand uses the constant bus.
475 bool usesConstantBus(const MachineRegisterInfo &MRI,
476 const MachineOperand &MO,
477 unsigned OpSize) const;
479 /// \brief Return true if this instruction has any modifiers.
480 /// e.g. src[012]_mod, omod, clamp.
481 bool hasModifiers(unsigned Opcode) const;
483 bool hasModifiersSet(const MachineInstr &MI,
484 unsigned OpName) const;
486 bool verifyInstruction(const MachineInstr &MI,
487 StringRef &ErrInfo) const override;
489 static unsigned getVALUOp(const MachineInstr &MI);
491 bool isSALUOpSupportedOnVALU(const MachineInstr &MI) const;
493 /// \brief Return the correct register class for \p OpNo. For target-specific
494 /// instructions, this will return the register class that has been defined
495 /// in tablegen. For generic instructions, like REG_SEQUENCE it will return
496 /// the register class of its machine operand.
497 /// to infer the correct register class base on the other operands.
498 const TargetRegisterClass *getOpRegClass(const MachineInstr &MI,
499 unsigned OpNo) const;
501 /// \brief Return the size in bytes of the operand OpNo on the given
502 // instruction opcode.
503 unsigned getOpSize(uint16_t Opcode, unsigned OpNo) const {
504 const MCOperandInfo &OpInfo = get(Opcode).OpInfo[OpNo];
506 if (OpInfo.RegClass == -1) {
507 // If this is an immediate operand, this must be a 32-bit literal.
508 assert(OpInfo.OperandType == MCOI::OPERAND_IMMEDIATE);
512 return RI.getRegClass(OpInfo.RegClass)->getSize();
515 /// \brief This form should usually be preferred since it handles operands
516 /// with unknown register classes.
517 unsigned getOpSize(const MachineInstr &MI, unsigned OpNo) const {
518 return getOpRegClass(MI, OpNo)->getSize();
521 /// \returns true if it is legal for the operand at index \p OpNo
523 bool canReadVGPR(const MachineInstr &MI, unsigned OpNo) const;
525 /// \brief Legalize the \p OpIndex operand of this instruction by inserting
526 /// a MOV. For example:
527 /// ADD_I32_e32 VGPR0, 15
530 /// ADD_I32_e32 VGPR0, VGPR1
532 /// If the operand being legalized is a register, then a COPY will be used
534 void legalizeOpWithMove(MachineInstr &MI, unsigned OpIdx) const;
536 /// \brief Check if \p MO is a legal operand if it was the \p OpIdx Operand
538 bool isOperandLegal(const MachineInstr &MI, unsigned OpIdx,
539 const MachineOperand *MO = nullptr) const;
541 /// \brief Check if \p MO would be a valid operand for the given operand
542 /// definition \p OpInfo. Note this does not attempt to validate constant bus
543 /// restrictions (e.g. literal constant usage).
544 bool isLegalVSrcOperand(const MachineRegisterInfo &MRI,
545 const MCOperandInfo &OpInfo,
546 const MachineOperand &MO) const;
548 /// \brief Check if \p MO (a register operand) is a legal register for the
549 /// given operand description.
550 bool isLegalRegOperand(const MachineRegisterInfo &MRI,
551 const MCOperandInfo &OpInfo,
552 const MachineOperand &MO) const;
554 /// \brief Legalize operands in \p MI by either commuting it or inserting a
556 void legalizeOperandsVOP2(MachineRegisterInfo &MRI, MachineInstr &MI) const;
558 /// \brief Fix operands in \p MI to satisfy constant bus requirements.
559 void legalizeOperandsVOP3(MachineRegisterInfo &MRI, MachineInstr &MI) const;
561 /// Copy a value from a VGPR (\p SrcReg) to SGPR. This function can only
562 /// be used when it is know that the value in SrcReg is same across all
563 /// threads in the wave.
564 /// \returns The SGPR register that \p SrcReg was copied to.
565 unsigned readlaneVGPRToSGPR(unsigned SrcReg, MachineInstr &UseMI,
566 MachineRegisterInfo &MRI) const;
568 void legalizeOperandsSMRD(MachineRegisterInfo &MRI, MachineInstr &MI) const;
570 void legalizeGenericOperand(MachineBasicBlock &InsertMBB,
571 MachineBasicBlock::iterator I,
572 const TargetRegisterClass *DstRC,
573 MachineOperand &Op, MachineRegisterInfo &MRI,
574 const DebugLoc &DL) const;
576 /// \brief Legalize all operands in this instruction. This function may
577 /// create new instruction and insert them before \p MI.
578 void legalizeOperands(MachineInstr &MI) const;
580 /// \brief Replace this instruction's opcode with the equivalent VALU
581 /// opcode. This function will also move the users of \p MI to the
582 /// VALU if necessary.
583 void moveToVALU(MachineInstr &MI) const;
585 void insertWaitStates(MachineBasicBlock &MBB,MachineBasicBlock::iterator MI,
588 void insertNoop(MachineBasicBlock &MBB,
589 MachineBasicBlock::iterator MI) const override;
591 /// \brief Return the number of wait states that result from executing this
593 unsigned getNumWaitStates(const MachineInstr &MI) const;
595 /// \brief Returns the operand named \p Op. If \p MI does not have an
596 /// operand named \c Op, this function returns nullptr.
598 MachineOperand *getNamedOperand(MachineInstr &MI, unsigned OperandName) const;
601 const MachineOperand *getNamedOperand(const MachineInstr &MI,
602 unsigned OpName) const {
603 return getNamedOperand(const_cast<MachineInstr &>(MI), OpName);
606 /// Get required immediate operand
607 int64_t getNamedImmOperand(const MachineInstr &MI, unsigned OpName) const {
608 int Idx = AMDGPU::getNamedOperandIdx(MI.getOpcode(), OpName);
609 return MI.getOperand(Idx).getImm();
612 uint64_t getDefaultRsrcDataFormat() const;
613 uint64_t getScratchRsrcWords23() const;
615 bool isLowLatencyInstruction(const MachineInstr &MI) const;
616 bool isHighLatencyInstruction(const MachineInstr &MI) const;
618 /// \brief Return the descriptor of the target-specific machine instruction
619 /// that corresponds to the specified pseudo or native opcode.
620 const MCInstrDesc &getMCOpcodeFromPseudo(unsigned Opcode) const {
621 return get(pseudoToMCOpcode(Opcode));
624 unsigned isStackAccess(const MachineInstr &MI, int &FrameIndex) const;
625 unsigned isSGPRStackAccess(const MachineInstr &MI, int &FrameIndex) const;
627 unsigned isLoadFromStackSlot(const MachineInstr &MI,
628 int &FrameIndex) const override;
629 unsigned isStoreToStackSlot(const MachineInstr &MI,
630 int &FrameIndex) const override;
632 unsigned getInstSizeInBytes(const MachineInstr &MI) const override;
634 bool mayAccessFlatAddressSpace(const MachineInstr &MI) const;
636 ArrayRef<std::pair<int, const char *>>
637 getSerializableTargetIndices() const override;
639 ScheduleHazardRecognizer *
640 CreateTargetPostRAHazardRecognizer(const InstrItineraryData *II,
641 const ScheduleDAG *DAG) const override;
643 ScheduleHazardRecognizer *
644 CreateTargetPostRAHazardRecognizer(const MachineFunction &MF) const override;
649 int getVOPe64(uint16_t Opcode);
652 int getVOPe32(uint16_t Opcode);
655 int getCommuteRev(uint16_t Opcode);
658 int getCommuteOrig(uint16_t Opcode);
661 int getAddr64Inst(uint16_t Opcode);
664 int getAtomicRetOp(uint16_t Opcode);
667 int getAtomicNoRetOp(uint16_t Opcode);
670 int getSOPKOp(uint16_t Opcode);
672 const uint64_t RSRC_DATA_FORMAT = 0xf00000000000LL;
673 const uint64_t RSRC_ELEMENT_SIZE_SHIFT = (32 + 19);
674 const uint64_t RSRC_INDEX_STRIDE_SHIFT = (32 + 21);
675 const uint64_t RSRC_TID_ENABLE = UINT64_C(1) << (32 + 23);
677 // For MachineOperands.
679 TF_LONG_BRANCH_FORWARD = 1 << 0,
680 TF_LONG_BRANCH_BACKWARD = 1 << 1
682 } // End namespace AMDGPU
685 namespace KernelInputOffsets {
687 /// Offsets in bytes from the start of the input buffer
700 } // End namespace KernelInputOffsets
701 } // End namespace SI
703 } // End namespace llvm