106f32e7eSjoerg //===- SIPeepholeSDWA.cpp - Peephole optimization for SDWA instructions ---===//
206f32e7eSjoerg //
306f32e7eSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
406f32e7eSjoerg // See https://llvm.org/LICENSE.txt for license information.
506f32e7eSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
606f32e7eSjoerg //
706f32e7eSjoerg //===----------------------------------------------------------------------===//
806f32e7eSjoerg //
906f32e7eSjoerg /// \file This pass tries to apply several peephole SDWA patterns.
1006f32e7eSjoerg ///
1106f32e7eSjoerg /// E.g. original:
1206f32e7eSjoerg /// V_LSHRREV_B32_e32 %0, 16, %1
13*da58b97aSjoerg /// V_ADD_CO_U32_e32 %2, %0, %3
1406f32e7eSjoerg /// V_LSHLREV_B32_e32 %4, 16, %2
1506f32e7eSjoerg ///
1606f32e7eSjoerg /// Replace:
17*da58b97aSjoerg /// V_ADD_CO_U32_sdwa %4, %1, %3
1806f32e7eSjoerg /// dst_sel:WORD_1 dst_unused:UNUSED_PAD src0_sel:WORD_1 src1_sel:DWORD
1906f32e7eSjoerg ///
2006f32e7eSjoerg //===----------------------------------------------------------------------===//
2106f32e7eSjoerg
2206f32e7eSjoerg #include "AMDGPU.h"
23*da58b97aSjoerg #include "GCNSubtarget.h"
2406f32e7eSjoerg #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
25*da58b97aSjoerg #include "llvm/ADT/MapVector.h"
2606f32e7eSjoerg #include "llvm/ADT/Statistic.h"
2706f32e7eSjoerg #include "llvm/CodeGen/MachineFunctionPass.h"
2806f32e7eSjoerg
2906f32e7eSjoerg using namespace llvm;
3006f32e7eSjoerg
3106f32e7eSjoerg #define DEBUG_TYPE "si-peephole-sdwa"
3206f32e7eSjoerg
3306f32e7eSjoerg STATISTIC(NumSDWAPatternsFound, "Number of SDWA patterns found.");
3406f32e7eSjoerg STATISTIC(NumSDWAInstructionsPeepholed,
3506f32e7eSjoerg "Number of instruction converted to SDWA.");
3606f32e7eSjoerg
3706f32e7eSjoerg namespace {
3806f32e7eSjoerg
3906f32e7eSjoerg class SDWAOperand;
4006f32e7eSjoerg class SDWADstOperand;
4106f32e7eSjoerg
4206f32e7eSjoerg class SIPeepholeSDWA : public MachineFunctionPass {
4306f32e7eSjoerg public:
4406f32e7eSjoerg using SDWAOperandsVector = SmallVector<SDWAOperand *, 4>;
4506f32e7eSjoerg
4606f32e7eSjoerg private:
4706f32e7eSjoerg MachineRegisterInfo *MRI;
4806f32e7eSjoerg const SIRegisterInfo *TRI;
4906f32e7eSjoerg const SIInstrInfo *TII;
5006f32e7eSjoerg
51*da58b97aSjoerg MapVector<MachineInstr *, std::unique_ptr<SDWAOperand>> SDWAOperands;
52*da58b97aSjoerg MapVector<MachineInstr *, SDWAOperandsVector> PotentialMatches;
5306f32e7eSjoerg SmallVector<MachineInstr *, 8> ConvertedInstructions;
5406f32e7eSjoerg
5506f32e7eSjoerg Optional<int64_t> foldToImm(const MachineOperand &Op) const;
5606f32e7eSjoerg
5706f32e7eSjoerg public:
5806f32e7eSjoerg static char ID;
5906f32e7eSjoerg
SIPeepholeSDWA()6006f32e7eSjoerg SIPeepholeSDWA() : MachineFunctionPass(ID) {
6106f32e7eSjoerg initializeSIPeepholeSDWAPass(*PassRegistry::getPassRegistry());
6206f32e7eSjoerg }
6306f32e7eSjoerg
6406f32e7eSjoerg bool runOnMachineFunction(MachineFunction &MF) override;
6506f32e7eSjoerg void matchSDWAOperands(MachineBasicBlock &MBB);
6606f32e7eSjoerg std::unique_ptr<SDWAOperand> matchSDWAOperand(MachineInstr &MI);
6706f32e7eSjoerg bool isConvertibleToSDWA(MachineInstr &MI, const GCNSubtarget &ST) const;
6806f32e7eSjoerg void pseudoOpConvertToVOP2(MachineInstr &MI,
6906f32e7eSjoerg const GCNSubtarget &ST) const;
7006f32e7eSjoerg bool convertToSDWA(MachineInstr &MI, const SDWAOperandsVector &SDWAOperands);
7106f32e7eSjoerg void legalizeScalarOperands(MachineInstr &MI, const GCNSubtarget &ST) const;
7206f32e7eSjoerg
getPassName() const7306f32e7eSjoerg StringRef getPassName() const override { return "SI Peephole SDWA"; }
7406f32e7eSjoerg
getAnalysisUsage(AnalysisUsage & AU) const7506f32e7eSjoerg void getAnalysisUsage(AnalysisUsage &AU) const override {
7606f32e7eSjoerg AU.setPreservesCFG();
7706f32e7eSjoerg MachineFunctionPass::getAnalysisUsage(AU);
7806f32e7eSjoerg }
7906f32e7eSjoerg };
8006f32e7eSjoerg
8106f32e7eSjoerg class SDWAOperand {
8206f32e7eSjoerg private:
8306f32e7eSjoerg MachineOperand *Target; // Operand that would be used in converted instruction
8406f32e7eSjoerg MachineOperand *Replaced; // Operand that would be replace by Target
8506f32e7eSjoerg
8606f32e7eSjoerg public:
SDWAOperand(MachineOperand * TargetOp,MachineOperand * ReplacedOp)8706f32e7eSjoerg SDWAOperand(MachineOperand *TargetOp, MachineOperand *ReplacedOp)
8806f32e7eSjoerg : Target(TargetOp), Replaced(ReplacedOp) {
8906f32e7eSjoerg assert(Target->isReg());
9006f32e7eSjoerg assert(Replaced->isReg());
9106f32e7eSjoerg }
9206f32e7eSjoerg
9306f32e7eSjoerg virtual ~SDWAOperand() = default;
9406f32e7eSjoerg
9506f32e7eSjoerg virtual MachineInstr *potentialToConvert(const SIInstrInfo *TII) = 0;
9606f32e7eSjoerg virtual bool convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) = 0;
9706f32e7eSjoerg
getTargetOperand() const9806f32e7eSjoerg MachineOperand *getTargetOperand() const { return Target; }
getReplacedOperand() const9906f32e7eSjoerg MachineOperand *getReplacedOperand() const { return Replaced; }
getParentInst() const10006f32e7eSjoerg MachineInstr *getParentInst() const { return Target->getParent(); }
10106f32e7eSjoerg
getMRI() const10206f32e7eSjoerg MachineRegisterInfo *getMRI() const {
10306f32e7eSjoerg return &getParentInst()->getParent()->getParent()->getRegInfo();
10406f32e7eSjoerg }
10506f32e7eSjoerg
10606f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
10706f32e7eSjoerg virtual void print(raw_ostream& OS) const = 0;
dump() const10806f32e7eSjoerg void dump() const { print(dbgs()); }
10906f32e7eSjoerg #endif
11006f32e7eSjoerg };
11106f32e7eSjoerg
11206f32e7eSjoerg using namespace AMDGPU::SDWA;
11306f32e7eSjoerg
11406f32e7eSjoerg class SDWASrcOperand : public SDWAOperand {
11506f32e7eSjoerg private:
11606f32e7eSjoerg SdwaSel SrcSel;
11706f32e7eSjoerg bool Abs;
11806f32e7eSjoerg bool Neg;
11906f32e7eSjoerg bool Sext;
12006f32e7eSjoerg
12106f32e7eSjoerg public:
SDWASrcOperand(MachineOperand * TargetOp,MachineOperand * ReplacedOp,SdwaSel SrcSel_=DWORD,bool Abs_=false,bool Neg_=false,bool Sext_=false)12206f32e7eSjoerg SDWASrcOperand(MachineOperand *TargetOp, MachineOperand *ReplacedOp,
12306f32e7eSjoerg SdwaSel SrcSel_ = DWORD, bool Abs_ = false, bool Neg_ = false,
12406f32e7eSjoerg bool Sext_ = false)
12506f32e7eSjoerg : SDWAOperand(TargetOp, ReplacedOp),
12606f32e7eSjoerg SrcSel(SrcSel_), Abs(Abs_), Neg(Neg_), Sext(Sext_) {}
12706f32e7eSjoerg
12806f32e7eSjoerg MachineInstr *potentialToConvert(const SIInstrInfo *TII) override;
12906f32e7eSjoerg bool convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) override;
13006f32e7eSjoerg
getSrcSel() const13106f32e7eSjoerg SdwaSel getSrcSel() const { return SrcSel; }
getAbs() const13206f32e7eSjoerg bool getAbs() const { return Abs; }
getNeg() const13306f32e7eSjoerg bool getNeg() const { return Neg; }
getSext() const13406f32e7eSjoerg bool getSext() const { return Sext; }
13506f32e7eSjoerg
13606f32e7eSjoerg uint64_t getSrcMods(const SIInstrInfo *TII,
13706f32e7eSjoerg const MachineOperand *SrcOp) const;
13806f32e7eSjoerg
13906f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
14006f32e7eSjoerg void print(raw_ostream& OS) const override;
14106f32e7eSjoerg #endif
14206f32e7eSjoerg };
14306f32e7eSjoerg
14406f32e7eSjoerg class SDWADstOperand : public SDWAOperand {
14506f32e7eSjoerg private:
14606f32e7eSjoerg SdwaSel DstSel;
14706f32e7eSjoerg DstUnused DstUn;
14806f32e7eSjoerg
14906f32e7eSjoerg public:
15006f32e7eSjoerg
SDWADstOperand(MachineOperand * TargetOp,MachineOperand * ReplacedOp,SdwaSel DstSel_=DWORD,DstUnused DstUn_=UNUSED_PAD)15106f32e7eSjoerg SDWADstOperand(MachineOperand *TargetOp, MachineOperand *ReplacedOp,
15206f32e7eSjoerg SdwaSel DstSel_ = DWORD, DstUnused DstUn_ = UNUSED_PAD)
15306f32e7eSjoerg : SDWAOperand(TargetOp, ReplacedOp), DstSel(DstSel_), DstUn(DstUn_) {}
15406f32e7eSjoerg
15506f32e7eSjoerg MachineInstr *potentialToConvert(const SIInstrInfo *TII) override;
15606f32e7eSjoerg bool convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) override;
15706f32e7eSjoerg
getDstSel() const15806f32e7eSjoerg SdwaSel getDstSel() const { return DstSel; }
getDstUnused() const15906f32e7eSjoerg DstUnused getDstUnused() const { return DstUn; }
16006f32e7eSjoerg
16106f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
16206f32e7eSjoerg void print(raw_ostream& OS) const override;
16306f32e7eSjoerg #endif
16406f32e7eSjoerg };
16506f32e7eSjoerg
16606f32e7eSjoerg class SDWADstPreserveOperand : public SDWADstOperand {
16706f32e7eSjoerg private:
16806f32e7eSjoerg MachineOperand *Preserve;
16906f32e7eSjoerg
17006f32e7eSjoerg public:
SDWADstPreserveOperand(MachineOperand * TargetOp,MachineOperand * ReplacedOp,MachineOperand * PreserveOp,SdwaSel DstSel_=DWORD)17106f32e7eSjoerg SDWADstPreserveOperand(MachineOperand *TargetOp, MachineOperand *ReplacedOp,
17206f32e7eSjoerg MachineOperand *PreserveOp, SdwaSel DstSel_ = DWORD)
17306f32e7eSjoerg : SDWADstOperand(TargetOp, ReplacedOp, DstSel_, UNUSED_PRESERVE),
17406f32e7eSjoerg Preserve(PreserveOp) {}
17506f32e7eSjoerg
17606f32e7eSjoerg bool convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) override;
17706f32e7eSjoerg
getPreservedOperand() const17806f32e7eSjoerg MachineOperand *getPreservedOperand() const { return Preserve; }
17906f32e7eSjoerg
18006f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
18106f32e7eSjoerg void print(raw_ostream& OS) const override;
18206f32e7eSjoerg #endif
18306f32e7eSjoerg };
18406f32e7eSjoerg
18506f32e7eSjoerg } // end anonymous namespace
18606f32e7eSjoerg
18706f32e7eSjoerg INITIALIZE_PASS(SIPeepholeSDWA, DEBUG_TYPE, "SI Peephole SDWA", false, false)
18806f32e7eSjoerg
18906f32e7eSjoerg char SIPeepholeSDWA::ID = 0;
19006f32e7eSjoerg
19106f32e7eSjoerg char &llvm::SIPeepholeSDWAID = SIPeepholeSDWA::ID;
19206f32e7eSjoerg
createSIPeepholeSDWAPass()19306f32e7eSjoerg FunctionPass *llvm::createSIPeepholeSDWAPass() {
19406f32e7eSjoerg return new SIPeepholeSDWA();
19506f32e7eSjoerg }
19606f32e7eSjoerg
19706f32e7eSjoerg
19806f32e7eSjoerg #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
operator <<(raw_ostream & OS,SdwaSel Sel)19906f32e7eSjoerg static raw_ostream& operator<<(raw_ostream &OS, SdwaSel Sel) {
20006f32e7eSjoerg switch(Sel) {
20106f32e7eSjoerg case BYTE_0: OS << "BYTE_0"; break;
20206f32e7eSjoerg case BYTE_1: OS << "BYTE_1"; break;
20306f32e7eSjoerg case BYTE_2: OS << "BYTE_2"; break;
20406f32e7eSjoerg case BYTE_3: OS << "BYTE_3"; break;
20506f32e7eSjoerg case WORD_0: OS << "WORD_0"; break;
20606f32e7eSjoerg case WORD_1: OS << "WORD_1"; break;
20706f32e7eSjoerg case DWORD: OS << "DWORD"; break;
20806f32e7eSjoerg }
20906f32e7eSjoerg return OS;
21006f32e7eSjoerg }
21106f32e7eSjoerg
operator <<(raw_ostream & OS,const DstUnused & Un)21206f32e7eSjoerg static raw_ostream& operator<<(raw_ostream &OS, const DstUnused &Un) {
21306f32e7eSjoerg switch(Un) {
21406f32e7eSjoerg case UNUSED_PAD: OS << "UNUSED_PAD"; break;
21506f32e7eSjoerg case UNUSED_SEXT: OS << "UNUSED_SEXT"; break;
21606f32e7eSjoerg case UNUSED_PRESERVE: OS << "UNUSED_PRESERVE"; break;
21706f32e7eSjoerg }
21806f32e7eSjoerg return OS;
21906f32e7eSjoerg }
22006f32e7eSjoerg
22106f32e7eSjoerg LLVM_DUMP_METHOD
print(raw_ostream & OS) const22206f32e7eSjoerg void SDWASrcOperand::print(raw_ostream& OS) const {
22306f32e7eSjoerg OS << "SDWA src: " << *getTargetOperand()
22406f32e7eSjoerg << " src_sel:" << getSrcSel()
22506f32e7eSjoerg << " abs:" << getAbs() << " neg:" << getNeg()
22606f32e7eSjoerg << " sext:" << getSext() << '\n';
22706f32e7eSjoerg }
22806f32e7eSjoerg
22906f32e7eSjoerg LLVM_DUMP_METHOD
print(raw_ostream & OS) const23006f32e7eSjoerg void SDWADstOperand::print(raw_ostream& OS) const {
23106f32e7eSjoerg OS << "SDWA dst: " << *getTargetOperand()
23206f32e7eSjoerg << " dst_sel:" << getDstSel()
23306f32e7eSjoerg << " dst_unused:" << getDstUnused() << '\n';
23406f32e7eSjoerg }
23506f32e7eSjoerg
23606f32e7eSjoerg LLVM_DUMP_METHOD
print(raw_ostream & OS) const23706f32e7eSjoerg void SDWADstPreserveOperand::print(raw_ostream& OS) const {
23806f32e7eSjoerg OS << "SDWA preserve dst: " << *getTargetOperand()
23906f32e7eSjoerg << " dst_sel:" << getDstSel()
24006f32e7eSjoerg << " preserve:" << *getPreservedOperand() << '\n';
24106f32e7eSjoerg }
24206f32e7eSjoerg
24306f32e7eSjoerg #endif
24406f32e7eSjoerg
copyRegOperand(MachineOperand & To,const MachineOperand & From)24506f32e7eSjoerg static void copyRegOperand(MachineOperand &To, const MachineOperand &From) {
24606f32e7eSjoerg assert(To.isReg() && From.isReg());
24706f32e7eSjoerg To.setReg(From.getReg());
24806f32e7eSjoerg To.setSubReg(From.getSubReg());
24906f32e7eSjoerg To.setIsUndef(From.isUndef());
25006f32e7eSjoerg if (To.isUse()) {
25106f32e7eSjoerg To.setIsKill(From.isKill());
25206f32e7eSjoerg } else {
25306f32e7eSjoerg To.setIsDead(From.isDead());
25406f32e7eSjoerg }
25506f32e7eSjoerg }
25606f32e7eSjoerg
isSameReg(const MachineOperand & LHS,const MachineOperand & RHS)25706f32e7eSjoerg static bool isSameReg(const MachineOperand &LHS, const MachineOperand &RHS) {
25806f32e7eSjoerg return LHS.isReg() &&
25906f32e7eSjoerg RHS.isReg() &&
26006f32e7eSjoerg LHS.getReg() == RHS.getReg() &&
26106f32e7eSjoerg LHS.getSubReg() == RHS.getSubReg();
26206f32e7eSjoerg }
26306f32e7eSjoerg
findSingleRegUse(const MachineOperand * Reg,const MachineRegisterInfo * MRI)26406f32e7eSjoerg static MachineOperand *findSingleRegUse(const MachineOperand *Reg,
26506f32e7eSjoerg const MachineRegisterInfo *MRI) {
26606f32e7eSjoerg if (!Reg->isReg() || !Reg->isDef())
26706f32e7eSjoerg return nullptr;
26806f32e7eSjoerg
26906f32e7eSjoerg MachineOperand *ResMO = nullptr;
27006f32e7eSjoerg for (MachineOperand &UseMO : MRI->use_nodbg_operands(Reg->getReg())) {
27106f32e7eSjoerg // If there exist use of subreg of Reg then return nullptr
27206f32e7eSjoerg if (!isSameReg(UseMO, *Reg))
27306f32e7eSjoerg return nullptr;
27406f32e7eSjoerg
27506f32e7eSjoerg // Check that there is only one instruction that uses Reg
27606f32e7eSjoerg if (!ResMO) {
27706f32e7eSjoerg ResMO = &UseMO;
27806f32e7eSjoerg } else if (ResMO->getParent() != UseMO.getParent()) {
27906f32e7eSjoerg return nullptr;
28006f32e7eSjoerg }
28106f32e7eSjoerg }
28206f32e7eSjoerg
28306f32e7eSjoerg return ResMO;
28406f32e7eSjoerg }
28506f32e7eSjoerg
findSingleRegDef(const MachineOperand * Reg,const MachineRegisterInfo * MRI)28606f32e7eSjoerg static MachineOperand *findSingleRegDef(const MachineOperand *Reg,
28706f32e7eSjoerg const MachineRegisterInfo *MRI) {
28806f32e7eSjoerg if (!Reg->isReg())
28906f32e7eSjoerg return nullptr;
29006f32e7eSjoerg
29106f32e7eSjoerg MachineInstr *DefInstr = MRI->getUniqueVRegDef(Reg->getReg());
29206f32e7eSjoerg if (!DefInstr)
29306f32e7eSjoerg return nullptr;
29406f32e7eSjoerg
29506f32e7eSjoerg for (auto &DefMO : DefInstr->defs()) {
29606f32e7eSjoerg if (DefMO.isReg() && DefMO.getReg() == Reg->getReg())
29706f32e7eSjoerg return &DefMO;
29806f32e7eSjoerg }
29906f32e7eSjoerg
30006f32e7eSjoerg // Ignore implicit defs.
30106f32e7eSjoerg return nullptr;
30206f32e7eSjoerg }
30306f32e7eSjoerg
getSrcMods(const SIInstrInfo * TII,const MachineOperand * SrcOp) const30406f32e7eSjoerg uint64_t SDWASrcOperand::getSrcMods(const SIInstrInfo *TII,
30506f32e7eSjoerg const MachineOperand *SrcOp) const {
30606f32e7eSjoerg uint64_t Mods = 0;
30706f32e7eSjoerg const auto *MI = SrcOp->getParent();
30806f32e7eSjoerg if (TII->getNamedOperand(*MI, AMDGPU::OpName::src0) == SrcOp) {
30906f32e7eSjoerg if (auto *Mod = TII->getNamedOperand(*MI, AMDGPU::OpName::src0_modifiers)) {
31006f32e7eSjoerg Mods = Mod->getImm();
31106f32e7eSjoerg }
31206f32e7eSjoerg } else if (TII->getNamedOperand(*MI, AMDGPU::OpName::src1) == SrcOp) {
31306f32e7eSjoerg if (auto *Mod = TII->getNamedOperand(*MI, AMDGPU::OpName::src1_modifiers)) {
31406f32e7eSjoerg Mods = Mod->getImm();
31506f32e7eSjoerg }
31606f32e7eSjoerg }
31706f32e7eSjoerg if (Abs || Neg) {
31806f32e7eSjoerg assert(!Sext &&
31906f32e7eSjoerg "Float and integer src modifiers can't be set simulteniously");
32006f32e7eSjoerg Mods |= Abs ? SISrcMods::ABS : 0u;
32106f32e7eSjoerg Mods ^= Neg ? SISrcMods::NEG : 0u;
32206f32e7eSjoerg } else if (Sext) {
32306f32e7eSjoerg Mods |= SISrcMods::SEXT;
32406f32e7eSjoerg }
32506f32e7eSjoerg
32606f32e7eSjoerg return Mods;
32706f32e7eSjoerg }
32806f32e7eSjoerg
potentialToConvert(const SIInstrInfo * TII)32906f32e7eSjoerg MachineInstr *SDWASrcOperand::potentialToConvert(const SIInstrInfo *TII) {
33006f32e7eSjoerg // For SDWA src operand potential instruction is one that use register
33106f32e7eSjoerg // defined by parent instruction
33206f32e7eSjoerg MachineOperand *PotentialMO = findSingleRegUse(getReplacedOperand(), getMRI());
33306f32e7eSjoerg if (!PotentialMO)
33406f32e7eSjoerg return nullptr;
33506f32e7eSjoerg
33606f32e7eSjoerg return PotentialMO->getParent();
33706f32e7eSjoerg }
33806f32e7eSjoerg
convertToSDWA(MachineInstr & MI,const SIInstrInfo * TII)33906f32e7eSjoerg bool SDWASrcOperand::convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) {
34006f32e7eSjoerg // Find operand in instruction that matches source operand and replace it with
34106f32e7eSjoerg // target operand. Set corresponding src_sel
34206f32e7eSjoerg bool IsPreserveSrc = false;
34306f32e7eSjoerg MachineOperand *Src = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
34406f32e7eSjoerg MachineOperand *SrcSel = TII->getNamedOperand(MI, AMDGPU::OpName::src0_sel);
34506f32e7eSjoerg MachineOperand *SrcMods =
34606f32e7eSjoerg TII->getNamedOperand(MI, AMDGPU::OpName::src0_modifiers);
34706f32e7eSjoerg assert(Src && (Src->isReg() || Src->isImm()));
34806f32e7eSjoerg if (!isSameReg(*Src, *getReplacedOperand())) {
34906f32e7eSjoerg // If this is not src0 then it could be src1
35006f32e7eSjoerg Src = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
35106f32e7eSjoerg SrcSel = TII->getNamedOperand(MI, AMDGPU::OpName::src1_sel);
35206f32e7eSjoerg SrcMods = TII->getNamedOperand(MI, AMDGPU::OpName::src1_modifiers);
35306f32e7eSjoerg
35406f32e7eSjoerg if (!Src ||
35506f32e7eSjoerg !isSameReg(*Src, *getReplacedOperand())) {
35606f32e7eSjoerg // It's possible this Src is a tied operand for
35706f32e7eSjoerg // UNUSED_PRESERVE, in which case we can either
35806f32e7eSjoerg // abandon the peephole attempt, or if legal we can
35906f32e7eSjoerg // copy the target operand into the tied slot
36006f32e7eSjoerg // if the preserve operation will effectively cause the same
36106f32e7eSjoerg // result by overwriting the rest of the dst.
36206f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
36306f32e7eSjoerg MachineOperand *DstUnused =
36406f32e7eSjoerg TII->getNamedOperand(MI, AMDGPU::OpName::dst_unused);
36506f32e7eSjoerg
36606f32e7eSjoerg if (Dst &&
36706f32e7eSjoerg DstUnused->getImm() == AMDGPU::SDWA::DstUnused::UNUSED_PRESERVE) {
36806f32e7eSjoerg // This will work if the tied src is acessing WORD_0, and the dst is
36906f32e7eSjoerg // writing WORD_1. Modifiers don't matter because all the bits that
37006f32e7eSjoerg // would be impacted are being overwritten by the dst.
37106f32e7eSjoerg // Any other case will not work.
37206f32e7eSjoerg SdwaSel DstSel = static_cast<SdwaSel>(
37306f32e7eSjoerg TII->getNamedImmOperand(MI, AMDGPU::OpName::dst_sel));
37406f32e7eSjoerg if (DstSel == AMDGPU::SDWA::SdwaSel::WORD_1 &&
37506f32e7eSjoerg getSrcSel() == AMDGPU::SDWA::SdwaSel::WORD_0) {
37606f32e7eSjoerg IsPreserveSrc = true;
37706f32e7eSjoerg auto DstIdx = AMDGPU::getNamedOperandIdx(MI.getOpcode(),
37806f32e7eSjoerg AMDGPU::OpName::vdst);
37906f32e7eSjoerg auto TiedIdx = MI.findTiedOperandIdx(DstIdx);
38006f32e7eSjoerg Src = &MI.getOperand(TiedIdx);
38106f32e7eSjoerg SrcSel = nullptr;
38206f32e7eSjoerg SrcMods = nullptr;
38306f32e7eSjoerg } else {
38406f32e7eSjoerg // Not legal to convert this src
38506f32e7eSjoerg return false;
38606f32e7eSjoerg }
38706f32e7eSjoerg }
38806f32e7eSjoerg }
38906f32e7eSjoerg assert(Src && Src->isReg());
39006f32e7eSjoerg
39106f32e7eSjoerg if ((MI.getOpcode() == AMDGPU::V_FMAC_F16_sdwa ||
39206f32e7eSjoerg MI.getOpcode() == AMDGPU::V_FMAC_F32_sdwa ||
39306f32e7eSjoerg MI.getOpcode() == AMDGPU::V_MAC_F16_sdwa ||
39406f32e7eSjoerg MI.getOpcode() == AMDGPU::V_MAC_F32_sdwa) &&
39506f32e7eSjoerg !isSameReg(*Src, *getReplacedOperand())) {
39606f32e7eSjoerg // In case of v_mac_f16/32_sdwa this pass can try to apply src operand to
39706f32e7eSjoerg // src2. This is not allowed.
39806f32e7eSjoerg return false;
39906f32e7eSjoerg }
40006f32e7eSjoerg
40106f32e7eSjoerg assert(isSameReg(*Src, *getReplacedOperand()) &&
40206f32e7eSjoerg (IsPreserveSrc || (SrcSel && SrcMods)));
40306f32e7eSjoerg }
40406f32e7eSjoerg copyRegOperand(*Src, *getTargetOperand());
40506f32e7eSjoerg if (!IsPreserveSrc) {
40606f32e7eSjoerg SrcSel->setImm(getSrcSel());
40706f32e7eSjoerg SrcMods->setImm(getSrcMods(TII, Src));
40806f32e7eSjoerg }
40906f32e7eSjoerg getTargetOperand()->setIsKill(false);
41006f32e7eSjoerg return true;
41106f32e7eSjoerg }
41206f32e7eSjoerg
potentialToConvert(const SIInstrInfo * TII)41306f32e7eSjoerg MachineInstr *SDWADstOperand::potentialToConvert(const SIInstrInfo *TII) {
41406f32e7eSjoerg // For SDWA dst operand potential instruction is one that defines register
41506f32e7eSjoerg // that this operand uses
41606f32e7eSjoerg MachineRegisterInfo *MRI = getMRI();
41706f32e7eSjoerg MachineInstr *ParentMI = getParentInst();
41806f32e7eSjoerg
41906f32e7eSjoerg MachineOperand *PotentialMO = findSingleRegDef(getReplacedOperand(), MRI);
42006f32e7eSjoerg if (!PotentialMO)
42106f32e7eSjoerg return nullptr;
42206f32e7eSjoerg
42306f32e7eSjoerg // Check that ParentMI is the only instruction that uses replaced register
42406f32e7eSjoerg for (MachineInstr &UseInst : MRI->use_nodbg_instructions(PotentialMO->getReg())) {
42506f32e7eSjoerg if (&UseInst != ParentMI)
42606f32e7eSjoerg return nullptr;
42706f32e7eSjoerg }
42806f32e7eSjoerg
42906f32e7eSjoerg return PotentialMO->getParent();
43006f32e7eSjoerg }
43106f32e7eSjoerg
convertToSDWA(MachineInstr & MI,const SIInstrInfo * TII)43206f32e7eSjoerg bool SDWADstOperand::convertToSDWA(MachineInstr &MI, const SIInstrInfo *TII) {
43306f32e7eSjoerg // Replace vdst operand in MI with target operand. Set dst_sel and dst_unused
43406f32e7eSjoerg
43506f32e7eSjoerg if ((MI.getOpcode() == AMDGPU::V_FMAC_F16_sdwa ||
43606f32e7eSjoerg MI.getOpcode() == AMDGPU::V_FMAC_F32_sdwa ||
43706f32e7eSjoerg MI.getOpcode() == AMDGPU::V_MAC_F16_sdwa ||
43806f32e7eSjoerg MI.getOpcode() == AMDGPU::V_MAC_F32_sdwa) &&
43906f32e7eSjoerg getDstSel() != AMDGPU::SDWA::DWORD) {
44006f32e7eSjoerg // v_mac_f16/32_sdwa allow dst_sel to be equal only to DWORD
44106f32e7eSjoerg return false;
44206f32e7eSjoerg }
44306f32e7eSjoerg
44406f32e7eSjoerg MachineOperand *Operand = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
44506f32e7eSjoerg assert(Operand &&
44606f32e7eSjoerg Operand->isReg() &&
44706f32e7eSjoerg isSameReg(*Operand, *getReplacedOperand()));
44806f32e7eSjoerg copyRegOperand(*Operand, *getTargetOperand());
44906f32e7eSjoerg MachineOperand *DstSel= TII->getNamedOperand(MI, AMDGPU::OpName::dst_sel);
45006f32e7eSjoerg assert(DstSel);
45106f32e7eSjoerg DstSel->setImm(getDstSel());
45206f32e7eSjoerg MachineOperand *DstUnused= TII->getNamedOperand(MI, AMDGPU::OpName::dst_unused);
45306f32e7eSjoerg assert(DstUnused);
45406f32e7eSjoerg DstUnused->setImm(getDstUnused());
45506f32e7eSjoerg
45606f32e7eSjoerg // Remove original instruction because it would conflict with our new
45706f32e7eSjoerg // instruction by register definition
45806f32e7eSjoerg getParentInst()->eraseFromParent();
45906f32e7eSjoerg return true;
46006f32e7eSjoerg }
46106f32e7eSjoerg
convertToSDWA(MachineInstr & MI,const SIInstrInfo * TII)46206f32e7eSjoerg bool SDWADstPreserveOperand::convertToSDWA(MachineInstr &MI,
46306f32e7eSjoerg const SIInstrInfo *TII) {
46406f32e7eSjoerg // MI should be moved right before v_or_b32.
46506f32e7eSjoerg // For this we should clear all kill flags on uses of MI src-operands or else
46606f32e7eSjoerg // we can encounter problem with use of killed operand.
46706f32e7eSjoerg for (MachineOperand &MO : MI.uses()) {
46806f32e7eSjoerg if (!MO.isReg())
46906f32e7eSjoerg continue;
47006f32e7eSjoerg getMRI()->clearKillFlags(MO.getReg());
47106f32e7eSjoerg }
47206f32e7eSjoerg
47306f32e7eSjoerg // Move MI before v_or_b32
47406f32e7eSjoerg auto MBB = MI.getParent();
47506f32e7eSjoerg MBB->remove(&MI);
47606f32e7eSjoerg MBB->insert(getParentInst(), &MI);
47706f32e7eSjoerg
47806f32e7eSjoerg // Add Implicit use of preserved register
47906f32e7eSjoerg MachineInstrBuilder MIB(*MBB->getParent(), MI);
48006f32e7eSjoerg MIB.addReg(getPreservedOperand()->getReg(),
48106f32e7eSjoerg RegState::ImplicitKill,
48206f32e7eSjoerg getPreservedOperand()->getSubReg());
48306f32e7eSjoerg
48406f32e7eSjoerg // Tie dst to implicit use
48506f32e7eSjoerg MI.tieOperands(AMDGPU::getNamedOperandIdx(MI.getOpcode(), AMDGPU::OpName::vdst),
48606f32e7eSjoerg MI.getNumOperands() - 1);
48706f32e7eSjoerg
48806f32e7eSjoerg // Convert MI as any other SDWADstOperand and remove v_or_b32
48906f32e7eSjoerg return SDWADstOperand::convertToSDWA(MI, TII);
49006f32e7eSjoerg }
49106f32e7eSjoerg
foldToImm(const MachineOperand & Op) const49206f32e7eSjoerg Optional<int64_t> SIPeepholeSDWA::foldToImm(const MachineOperand &Op) const {
49306f32e7eSjoerg if (Op.isImm()) {
49406f32e7eSjoerg return Op.getImm();
49506f32e7eSjoerg }
49606f32e7eSjoerg
49706f32e7eSjoerg // If this is not immediate then it can be copy of immediate value, e.g.:
49806f32e7eSjoerg // %1 = S_MOV_B32 255;
49906f32e7eSjoerg if (Op.isReg()) {
50006f32e7eSjoerg for (const MachineOperand &Def : MRI->def_operands(Op.getReg())) {
50106f32e7eSjoerg if (!isSameReg(Op, Def))
50206f32e7eSjoerg continue;
50306f32e7eSjoerg
50406f32e7eSjoerg const MachineInstr *DefInst = Def.getParent();
50506f32e7eSjoerg if (!TII->isFoldableCopy(*DefInst))
50606f32e7eSjoerg return None;
50706f32e7eSjoerg
50806f32e7eSjoerg const MachineOperand &Copied = DefInst->getOperand(1);
50906f32e7eSjoerg if (!Copied.isImm())
51006f32e7eSjoerg return None;
51106f32e7eSjoerg
51206f32e7eSjoerg return Copied.getImm();
51306f32e7eSjoerg }
51406f32e7eSjoerg }
51506f32e7eSjoerg
51606f32e7eSjoerg return None;
51706f32e7eSjoerg }
51806f32e7eSjoerg
51906f32e7eSjoerg std::unique_ptr<SDWAOperand>
matchSDWAOperand(MachineInstr & MI)52006f32e7eSjoerg SIPeepholeSDWA::matchSDWAOperand(MachineInstr &MI) {
52106f32e7eSjoerg unsigned Opcode = MI.getOpcode();
52206f32e7eSjoerg switch (Opcode) {
52306f32e7eSjoerg case AMDGPU::V_LSHRREV_B32_e32:
52406f32e7eSjoerg case AMDGPU::V_ASHRREV_I32_e32:
52506f32e7eSjoerg case AMDGPU::V_LSHLREV_B32_e32:
52606f32e7eSjoerg case AMDGPU::V_LSHRREV_B32_e64:
52706f32e7eSjoerg case AMDGPU::V_ASHRREV_I32_e64:
52806f32e7eSjoerg case AMDGPU::V_LSHLREV_B32_e64: {
52906f32e7eSjoerg // from: v_lshrrev_b32_e32 v1, 16/24, v0
53006f32e7eSjoerg // to SDWA src:v0 src_sel:WORD_1/BYTE_3
53106f32e7eSjoerg
53206f32e7eSjoerg // from: v_ashrrev_i32_e32 v1, 16/24, v0
53306f32e7eSjoerg // to SDWA src:v0 src_sel:WORD_1/BYTE_3 sext:1
53406f32e7eSjoerg
53506f32e7eSjoerg // from: v_lshlrev_b32_e32 v1, 16/24, v0
53606f32e7eSjoerg // to SDWA dst:v1 dst_sel:WORD_1/BYTE_3 dst_unused:UNUSED_PAD
53706f32e7eSjoerg MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
53806f32e7eSjoerg auto Imm = foldToImm(*Src0);
53906f32e7eSjoerg if (!Imm)
54006f32e7eSjoerg break;
54106f32e7eSjoerg
54206f32e7eSjoerg if (*Imm != 16 && *Imm != 24)
54306f32e7eSjoerg break;
54406f32e7eSjoerg
54506f32e7eSjoerg MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
54606f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
547*da58b97aSjoerg if (Src1->getReg().isPhysical() || Dst->getReg().isPhysical())
54806f32e7eSjoerg break;
54906f32e7eSjoerg
55006f32e7eSjoerg if (Opcode == AMDGPU::V_LSHLREV_B32_e32 ||
55106f32e7eSjoerg Opcode == AMDGPU::V_LSHLREV_B32_e64) {
55206f32e7eSjoerg return std::make_unique<SDWADstOperand>(
55306f32e7eSjoerg Dst, Src1, *Imm == 16 ? WORD_1 : BYTE_3, UNUSED_PAD);
55406f32e7eSjoerg } else {
55506f32e7eSjoerg return std::make_unique<SDWASrcOperand>(
55606f32e7eSjoerg Src1, Dst, *Imm == 16 ? WORD_1 : BYTE_3, false, false,
55706f32e7eSjoerg Opcode != AMDGPU::V_LSHRREV_B32_e32 &&
55806f32e7eSjoerg Opcode != AMDGPU::V_LSHRREV_B32_e64);
55906f32e7eSjoerg }
56006f32e7eSjoerg break;
56106f32e7eSjoerg }
56206f32e7eSjoerg
56306f32e7eSjoerg case AMDGPU::V_LSHRREV_B16_e32:
56406f32e7eSjoerg case AMDGPU::V_ASHRREV_I16_e32:
56506f32e7eSjoerg case AMDGPU::V_LSHLREV_B16_e32:
56606f32e7eSjoerg case AMDGPU::V_LSHRREV_B16_e64:
56706f32e7eSjoerg case AMDGPU::V_ASHRREV_I16_e64:
56806f32e7eSjoerg case AMDGPU::V_LSHLREV_B16_e64: {
56906f32e7eSjoerg // from: v_lshrrev_b16_e32 v1, 8, v0
57006f32e7eSjoerg // to SDWA src:v0 src_sel:BYTE_1
57106f32e7eSjoerg
57206f32e7eSjoerg // from: v_ashrrev_i16_e32 v1, 8, v0
57306f32e7eSjoerg // to SDWA src:v0 src_sel:BYTE_1 sext:1
57406f32e7eSjoerg
57506f32e7eSjoerg // from: v_lshlrev_b16_e32 v1, 8, v0
57606f32e7eSjoerg // to SDWA dst:v1 dst_sel:BYTE_1 dst_unused:UNUSED_PAD
57706f32e7eSjoerg MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
57806f32e7eSjoerg auto Imm = foldToImm(*Src0);
57906f32e7eSjoerg if (!Imm || *Imm != 8)
58006f32e7eSjoerg break;
58106f32e7eSjoerg
58206f32e7eSjoerg MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
58306f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
58406f32e7eSjoerg
585*da58b97aSjoerg if (Src1->getReg().isPhysical() || Dst->getReg().isPhysical())
58606f32e7eSjoerg break;
58706f32e7eSjoerg
58806f32e7eSjoerg if (Opcode == AMDGPU::V_LSHLREV_B16_e32 ||
58906f32e7eSjoerg Opcode == AMDGPU::V_LSHLREV_B16_e64) {
59006f32e7eSjoerg return std::make_unique<SDWADstOperand>(Dst, Src1, BYTE_1, UNUSED_PAD);
59106f32e7eSjoerg } else {
59206f32e7eSjoerg return std::make_unique<SDWASrcOperand>(
59306f32e7eSjoerg Src1, Dst, BYTE_1, false, false,
59406f32e7eSjoerg Opcode != AMDGPU::V_LSHRREV_B16_e32 &&
59506f32e7eSjoerg Opcode != AMDGPU::V_LSHRREV_B16_e64);
59606f32e7eSjoerg }
59706f32e7eSjoerg break;
59806f32e7eSjoerg }
59906f32e7eSjoerg
600*da58b97aSjoerg case AMDGPU::V_BFE_I32_e64:
601*da58b97aSjoerg case AMDGPU::V_BFE_U32_e64: {
60206f32e7eSjoerg // e.g.:
60306f32e7eSjoerg // from: v_bfe_u32 v1, v0, 8, 8
60406f32e7eSjoerg // to SDWA src:v0 src_sel:BYTE_1
60506f32e7eSjoerg
60606f32e7eSjoerg // offset | width | src_sel
60706f32e7eSjoerg // ------------------------
60806f32e7eSjoerg // 0 | 8 | BYTE_0
60906f32e7eSjoerg // 0 | 16 | WORD_0
61006f32e7eSjoerg // 0 | 32 | DWORD ?
61106f32e7eSjoerg // 8 | 8 | BYTE_1
61206f32e7eSjoerg // 16 | 8 | BYTE_2
61306f32e7eSjoerg // 16 | 16 | WORD_1
61406f32e7eSjoerg // 24 | 8 | BYTE_3
61506f32e7eSjoerg
61606f32e7eSjoerg MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
61706f32e7eSjoerg auto Offset = foldToImm(*Src1);
61806f32e7eSjoerg if (!Offset)
61906f32e7eSjoerg break;
62006f32e7eSjoerg
62106f32e7eSjoerg MachineOperand *Src2 = TII->getNamedOperand(MI, AMDGPU::OpName::src2);
62206f32e7eSjoerg auto Width = foldToImm(*Src2);
62306f32e7eSjoerg if (!Width)
62406f32e7eSjoerg break;
62506f32e7eSjoerg
62606f32e7eSjoerg SdwaSel SrcSel = DWORD;
62706f32e7eSjoerg
62806f32e7eSjoerg if (*Offset == 0 && *Width == 8)
62906f32e7eSjoerg SrcSel = BYTE_0;
63006f32e7eSjoerg else if (*Offset == 0 && *Width == 16)
63106f32e7eSjoerg SrcSel = WORD_0;
63206f32e7eSjoerg else if (*Offset == 0 && *Width == 32)
63306f32e7eSjoerg SrcSel = DWORD;
63406f32e7eSjoerg else if (*Offset == 8 && *Width == 8)
63506f32e7eSjoerg SrcSel = BYTE_1;
63606f32e7eSjoerg else if (*Offset == 16 && *Width == 8)
63706f32e7eSjoerg SrcSel = BYTE_2;
63806f32e7eSjoerg else if (*Offset == 16 && *Width == 16)
63906f32e7eSjoerg SrcSel = WORD_1;
64006f32e7eSjoerg else if (*Offset == 24 && *Width == 8)
64106f32e7eSjoerg SrcSel = BYTE_3;
64206f32e7eSjoerg else
64306f32e7eSjoerg break;
64406f32e7eSjoerg
64506f32e7eSjoerg MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
64606f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
64706f32e7eSjoerg
648*da58b97aSjoerg if (Src0->getReg().isPhysical() || Dst->getReg().isPhysical())
64906f32e7eSjoerg break;
65006f32e7eSjoerg
65106f32e7eSjoerg return std::make_unique<SDWASrcOperand>(
652*da58b97aSjoerg Src0, Dst, SrcSel, false, false, Opcode != AMDGPU::V_BFE_U32_e64);
65306f32e7eSjoerg }
65406f32e7eSjoerg
65506f32e7eSjoerg case AMDGPU::V_AND_B32_e32:
65606f32e7eSjoerg case AMDGPU::V_AND_B32_e64: {
65706f32e7eSjoerg // e.g.:
65806f32e7eSjoerg // from: v_and_b32_e32 v1, 0x0000ffff/0x000000ff, v0
65906f32e7eSjoerg // to SDWA src:v0 src_sel:WORD_0/BYTE_0
66006f32e7eSjoerg
66106f32e7eSjoerg MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
66206f32e7eSjoerg MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
66306f32e7eSjoerg auto ValSrc = Src1;
66406f32e7eSjoerg auto Imm = foldToImm(*Src0);
66506f32e7eSjoerg
66606f32e7eSjoerg if (!Imm) {
66706f32e7eSjoerg Imm = foldToImm(*Src1);
66806f32e7eSjoerg ValSrc = Src0;
66906f32e7eSjoerg }
67006f32e7eSjoerg
67106f32e7eSjoerg if (!Imm || (*Imm != 0x0000ffff && *Imm != 0x000000ff))
67206f32e7eSjoerg break;
67306f32e7eSjoerg
67406f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
67506f32e7eSjoerg
676*da58b97aSjoerg if (ValSrc->getReg().isPhysical() || Dst->getReg().isPhysical())
67706f32e7eSjoerg break;
67806f32e7eSjoerg
67906f32e7eSjoerg return std::make_unique<SDWASrcOperand>(
68006f32e7eSjoerg ValSrc, Dst, *Imm == 0x0000ffff ? WORD_0 : BYTE_0);
68106f32e7eSjoerg }
68206f32e7eSjoerg
68306f32e7eSjoerg case AMDGPU::V_OR_B32_e32:
68406f32e7eSjoerg case AMDGPU::V_OR_B32_e64: {
68506f32e7eSjoerg // Patterns for dst_unused:UNUSED_PRESERVE.
68606f32e7eSjoerg // e.g., from:
68706f32e7eSjoerg // v_add_f16_sdwa v0, v1, v2 dst_sel:WORD_1 dst_unused:UNUSED_PAD
68806f32e7eSjoerg // src1_sel:WORD_1 src2_sel:WORD1
68906f32e7eSjoerg // v_add_f16_e32 v3, v1, v2
69006f32e7eSjoerg // v_or_b32_e32 v4, v0, v3
69106f32e7eSjoerg // to SDWA preserve dst:v4 dst_sel:WORD_1 dst_unused:UNUSED_PRESERVE preserve:v3
69206f32e7eSjoerg
69306f32e7eSjoerg // Check if one of operands of v_or_b32 is SDWA instruction
69406f32e7eSjoerg using CheckRetType = Optional<std::pair<MachineOperand *, MachineOperand *>>;
69506f32e7eSjoerg auto CheckOROperandsForSDWA =
69606f32e7eSjoerg [&](const MachineOperand *Op1, const MachineOperand *Op2) -> CheckRetType {
69706f32e7eSjoerg if (!Op1 || !Op1->isReg() || !Op2 || !Op2->isReg())
69806f32e7eSjoerg return CheckRetType(None);
69906f32e7eSjoerg
70006f32e7eSjoerg MachineOperand *Op1Def = findSingleRegDef(Op1, MRI);
70106f32e7eSjoerg if (!Op1Def)
70206f32e7eSjoerg return CheckRetType(None);
70306f32e7eSjoerg
70406f32e7eSjoerg MachineInstr *Op1Inst = Op1Def->getParent();
70506f32e7eSjoerg if (!TII->isSDWA(*Op1Inst))
70606f32e7eSjoerg return CheckRetType(None);
70706f32e7eSjoerg
70806f32e7eSjoerg MachineOperand *Op2Def = findSingleRegDef(Op2, MRI);
70906f32e7eSjoerg if (!Op2Def)
71006f32e7eSjoerg return CheckRetType(None);
71106f32e7eSjoerg
71206f32e7eSjoerg return CheckRetType(std::make_pair(Op1Def, Op2Def));
71306f32e7eSjoerg };
71406f32e7eSjoerg
71506f32e7eSjoerg MachineOperand *OrSDWA = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
71606f32e7eSjoerg MachineOperand *OrOther = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
71706f32e7eSjoerg assert(OrSDWA && OrOther);
71806f32e7eSjoerg auto Res = CheckOROperandsForSDWA(OrSDWA, OrOther);
71906f32e7eSjoerg if (!Res) {
72006f32e7eSjoerg OrSDWA = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
72106f32e7eSjoerg OrOther = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
72206f32e7eSjoerg assert(OrSDWA && OrOther);
72306f32e7eSjoerg Res = CheckOROperandsForSDWA(OrSDWA, OrOther);
72406f32e7eSjoerg if (!Res)
72506f32e7eSjoerg break;
72606f32e7eSjoerg }
72706f32e7eSjoerg
72806f32e7eSjoerg MachineOperand *OrSDWADef = Res->first;
72906f32e7eSjoerg MachineOperand *OrOtherDef = Res->second;
73006f32e7eSjoerg assert(OrSDWADef && OrOtherDef);
73106f32e7eSjoerg
73206f32e7eSjoerg MachineInstr *SDWAInst = OrSDWADef->getParent();
73306f32e7eSjoerg MachineInstr *OtherInst = OrOtherDef->getParent();
73406f32e7eSjoerg
73506f32e7eSjoerg // Check that OtherInstr is actually bitwise compatible with SDWAInst = their
73606f32e7eSjoerg // destination patterns don't overlap. Compatible instruction can be either
73706f32e7eSjoerg // regular instruction with compatible bitness or SDWA instruction with
73806f32e7eSjoerg // correct dst_sel
73906f32e7eSjoerg // SDWAInst | OtherInst bitness / OtherInst dst_sel
74006f32e7eSjoerg // -----------------------------------------------------
74106f32e7eSjoerg // DWORD | no / no
74206f32e7eSjoerg // WORD_0 | no / BYTE_2/3, WORD_1
74306f32e7eSjoerg // WORD_1 | 8/16-bit instructions / BYTE_0/1, WORD_0
74406f32e7eSjoerg // BYTE_0 | no / BYTE_1/2/3, WORD_1
74506f32e7eSjoerg // BYTE_1 | 8-bit / BYTE_0/2/3, WORD_1
74606f32e7eSjoerg // BYTE_2 | 8/16-bit / BYTE_0/1/3. WORD_0
74706f32e7eSjoerg // BYTE_3 | 8/16/24-bit / BYTE_0/1/2, WORD_0
74806f32e7eSjoerg // E.g. if SDWAInst is v_add_f16_sdwa dst_sel:WORD_1 then v_add_f16 is OK
74906f32e7eSjoerg // but v_add_f32 is not.
75006f32e7eSjoerg
75106f32e7eSjoerg // TODO: add support for non-SDWA instructions as OtherInst.
75206f32e7eSjoerg // For now this only works with SDWA instructions. For regular instructions
75306f32e7eSjoerg // there is no way to determine if the instruction writes only 8/16/24-bit
75406f32e7eSjoerg // out of full register size and all registers are at min 32-bit wide.
75506f32e7eSjoerg if (!TII->isSDWA(*OtherInst))
75606f32e7eSjoerg break;
75706f32e7eSjoerg
75806f32e7eSjoerg SdwaSel DstSel = static_cast<SdwaSel>(
75906f32e7eSjoerg TII->getNamedImmOperand(*SDWAInst, AMDGPU::OpName::dst_sel));;
76006f32e7eSjoerg SdwaSel OtherDstSel = static_cast<SdwaSel>(
76106f32e7eSjoerg TII->getNamedImmOperand(*OtherInst, AMDGPU::OpName::dst_sel));
76206f32e7eSjoerg
76306f32e7eSjoerg bool DstSelAgree = false;
76406f32e7eSjoerg switch (DstSel) {
76506f32e7eSjoerg case WORD_0: DstSelAgree = ((OtherDstSel == BYTE_2) ||
76606f32e7eSjoerg (OtherDstSel == BYTE_3) ||
76706f32e7eSjoerg (OtherDstSel == WORD_1));
76806f32e7eSjoerg break;
76906f32e7eSjoerg case WORD_1: DstSelAgree = ((OtherDstSel == BYTE_0) ||
77006f32e7eSjoerg (OtherDstSel == BYTE_1) ||
77106f32e7eSjoerg (OtherDstSel == WORD_0));
77206f32e7eSjoerg break;
77306f32e7eSjoerg case BYTE_0: DstSelAgree = ((OtherDstSel == BYTE_1) ||
77406f32e7eSjoerg (OtherDstSel == BYTE_2) ||
77506f32e7eSjoerg (OtherDstSel == BYTE_3) ||
77606f32e7eSjoerg (OtherDstSel == WORD_1));
77706f32e7eSjoerg break;
77806f32e7eSjoerg case BYTE_1: DstSelAgree = ((OtherDstSel == BYTE_0) ||
77906f32e7eSjoerg (OtherDstSel == BYTE_2) ||
78006f32e7eSjoerg (OtherDstSel == BYTE_3) ||
78106f32e7eSjoerg (OtherDstSel == WORD_1));
78206f32e7eSjoerg break;
78306f32e7eSjoerg case BYTE_2: DstSelAgree = ((OtherDstSel == BYTE_0) ||
78406f32e7eSjoerg (OtherDstSel == BYTE_1) ||
78506f32e7eSjoerg (OtherDstSel == BYTE_3) ||
78606f32e7eSjoerg (OtherDstSel == WORD_0));
78706f32e7eSjoerg break;
78806f32e7eSjoerg case BYTE_3: DstSelAgree = ((OtherDstSel == BYTE_0) ||
78906f32e7eSjoerg (OtherDstSel == BYTE_1) ||
79006f32e7eSjoerg (OtherDstSel == BYTE_2) ||
79106f32e7eSjoerg (OtherDstSel == WORD_0));
79206f32e7eSjoerg break;
79306f32e7eSjoerg default: DstSelAgree = false;
79406f32e7eSjoerg }
79506f32e7eSjoerg
79606f32e7eSjoerg if (!DstSelAgree)
79706f32e7eSjoerg break;
79806f32e7eSjoerg
79906f32e7eSjoerg // Also OtherInst dst_unused should be UNUSED_PAD
80006f32e7eSjoerg DstUnused OtherDstUnused = static_cast<DstUnused>(
80106f32e7eSjoerg TII->getNamedImmOperand(*OtherInst, AMDGPU::OpName::dst_unused));
80206f32e7eSjoerg if (OtherDstUnused != DstUnused::UNUSED_PAD)
80306f32e7eSjoerg break;
80406f32e7eSjoerg
80506f32e7eSjoerg // Create DstPreserveOperand
80606f32e7eSjoerg MachineOperand *OrDst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
80706f32e7eSjoerg assert(OrDst && OrDst->isReg());
80806f32e7eSjoerg
80906f32e7eSjoerg return std::make_unique<SDWADstPreserveOperand>(
81006f32e7eSjoerg OrDst, OrSDWADef, OrOtherDef, DstSel);
81106f32e7eSjoerg
81206f32e7eSjoerg }
81306f32e7eSjoerg }
81406f32e7eSjoerg
81506f32e7eSjoerg return std::unique_ptr<SDWAOperand>(nullptr);
81606f32e7eSjoerg }
81706f32e7eSjoerg
818*da58b97aSjoerg #if !defined(NDEBUG)
operator <<(raw_ostream & OS,const SDWAOperand & Operand)819*da58b97aSjoerg static raw_ostream& operator<<(raw_ostream &OS, const SDWAOperand &Operand) {
820*da58b97aSjoerg Operand.print(OS);
821*da58b97aSjoerg return OS;
822*da58b97aSjoerg }
823*da58b97aSjoerg #endif
824*da58b97aSjoerg
matchSDWAOperands(MachineBasicBlock & MBB)82506f32e7eSjoerg void SIPeepholeSDWA::matchSDWAOperands(MachineBasicBlock &MBB) {
82606f32e7eSjoerg for (MachineInstr &MI : MBB) {
82706f32e7eSjoerg if (auto Operand = matchSDWAOperand(MI)) {
82806f32e7eSjoerg LLVM_DEBUG(dbgs() << "Match: " << MI << "To: " << *Operand << '\n');
82906f32e7eSjoerg SDWAOperands[&MI] = std::move(Operand);
83006f32e7eSjoerg ++NumSDWAPatternsFound;
83106f32e7eSjoerg }
83206f32e7eSjoerg }
83306f32e7eSjoerg }
83406f32e7eSjoerg
83506f32e7eSjoerg // Convert the V_ADDC_U32_e64 into V_ADDC_U32_e32, and
836*da58b97aSjoerg // V_ADD_CO_U32_e64 into V_ADD_CO_U32_e32. This allows isConvertibleToSDWA
837*da58b97aSjoerg // to perform its transformation on V_ADD_CO_U32_e32 into V_ADD_CO_U32_sdwa.
83806f32e7eSjoerg //
83906f32e7eSjoerg // We are transforming from a VOP3 into a VOP2 form of the instruction.
84006f32e7eSjoerg // %19:vgpr_32 = V_AND_B32_e32 255,
84106f32e7eSjoerg // killed %16:vgpr_32, implicit $exec
842*da58b97aSjoerg // %47:vgpr_32, %49:sreg_64_xexec = V_ADD_CO_U32_e64
84306f32e7eSjoerg // %26.sub0:vreg_64, %19:vgpr_32, implicit $exec
84406f32e7eSjoerg // %48:vgpr_32, dead %50:sreg_64_xexec = V_ADDC_U32_e64
84506f32e7eSjoerg // %26.sub1:vreg_64, %54:vgpr_32, killed %49:sreg_64_xexec, implicit $exec
84606f32e7eSjoerg //
84706f32e7eSjoerg // becomes
848*da58b97aSjoerg // %47:vgpr_32 = V_ADD_CO_U32_sdwa
84906f32e7eSjoerg // 0, %26.sub0:vreg_64, 0, killed %16:vgpr_32, 0, 6, 0, 6, 0,
85006f32e7eSjoerg // implicit-def $vcc, implicit $exec
85106f32e7eSjoerg // %48:vgpr_32 = V_ADDC_U32_e32
85206f32e7eSjoerg // 0, %26.sub1:vreg_64, implicit-def $vcc, implicit $vcc, implicit $exec
pseudoOpConvertToVOP2(MachineInstr & MI,const GCNSubtarget & ST) const85306f32e7eSjoerg void SIPeepholeSDWA::pseudoOpConvertToVOP2(MachineInstr &MI,
85406f32e7eSjoerg const GCNSubtarget &ST) const {
85506f32e7eSjoerg int Opc = MI.getOpcode();
856*da58b97aSjoerg assert((Opc == AMDGPU::V_ADD_CO_U32_e64 || Opc == AMDGPU::V_SUB_CO_U32_e64) &&
857*da58b97aSjoerg "Currently only handles V_ADD_CO_U32_e64 or V_SUB_CO_U32_e64");
85806f32e7eSjoerg
85906f32e7eSjoerg // Can the candidate MI be shrunk?
86006f32e7eSjoerg if (!TII->canShrink(MI, *MRI))
86106f32e7eSjoerg return;
86206f32e7eSjoerg Opc = AMDGPU::getVOPe32(Opc);
86306f32e7eSjoerg // Find the related ADD instruction.
86406f32e7eSjoerg const MachineOperand *Sdst = TII->getNamedOperand(MI, AMDGPU::OpName::sdst);
86506f32e7eSjoerg if (!Sdst)
86606f32e7eSjoerg return;
86706f32e7eSjoerg MachineOperand *NextOp = findSingleRegUse(Sdst, MRI);
86806f32e7eSjoerg if (!NextOp)
86906f32e7eSjoerg return;
87006f32e7eSjoerg MachineInstr &MISucc = *NextOp->getParent();
87106f32e7eSjoerg // Can the successor be shrunk?
87206f32e7eSjoerg if (!TII->canShrink(MISucc, *MRI))
87306f32e7eSjoerg return;
87406f32e7eSjoerg int SuccOpc = AMDGPU::getVOPe32(MISucc.getOpcode());
87506f32e7eSjoerg // Make sure the carry in/out are subsequently unused.
87606f32e7eSjoerg MachineOperand *CarryIn = TII->getNamedOperand(MISucc, AMDGPU::OpName::src2);
87706f32e7eSjoerg if (!CarryIn)
87806f32e7eSjoerg return;
87906f32e7eSjoerg MachineOperand *CarryOut = TII->getNamedOperand(MISucc, AMDGPU::OpName::sdst);
88006f32e7eSjoerg if (!CarryOut)
88106f32e7eSjoerg return;
88206f32e7eSjoerg if (!MRI->hasOneUse(CarryIn->getReg()) || !MRI->use_empty(CarryOut->getReg()))
88306f32e7eSjoerg return;
88406f32e7eSjoerg // Make sure VCC or its subregs are dead before MI.
88506f32e7eSjoerg MachineBasicBlock &MBB = *MI.getParent();
88606f32e7eSjoerg auto Liveness = MBB.computeRegisterLiveness(TRI, AMDGPU::VCC, MI, 25);
88706f32e7eSjoerg if (Liveness != MachineBasicBlock::LQR_Dead)
88806f32e7eSjoerg return;
88906f32e7eSjoerg // Check if VCC is referenced in range of (MI,MISucc].
89006f32e7eSjoerg for (auto I = std::next(MI.getIterator()), E = MISucc.getIterator();
89106f32e7eSjoerg I != E; ++I) {
89206f32e7eSjoerg if (I->modifiesRegister(AMDGPU::VCC, TRI))
89306f32e7eSjoerg return;
89406f32e7eSjoerg }
895*da58b97aSjoerg
89606f32e7eSjoerg // Make the two new e32 instruction variants.
89706f32e7eSjoerg // Replace MI with V_{SUB|ADD}_I32_e32
898*da58b97aSjoerg BuildMI(MBB, MI, MI.getDebugLoc(), TII->get(Opc))
899*da58b97aSjoerg .add(*TII->getNamedOperand(MI, AMDGPU::OpName::vdst))
900*da58b97aSjoerg .add(*TII->getNamedOperand(MI, AMDGPU::OpName::src0))
901*da58b97aSjoerg .add(*TII->getNamedOperand(MI, AMDGPU::OpName::src1))
902*da58b97aSjoerg .setMIFlags(MI.getFlags());
903*da58b97aSjoerg
90406f32e7eSjoerg MI.eraseFromParent();
905*da58b97aSjoerg
90606f32e7eSjoerg // Replace MISucc with V_{SUBB|ADDC}_U32_e32
907*da58b97aSjoerg BuildMI(MBB, MISucc, MISucc.getDebugLoc(), TII->get(SuccOpc))
908*da58b97aSjoerg .add(*TII->getNamedOperand(MISucc, AMDGPU::OpName::vdst))
909*da58b97aSjoerg .add(*TII->getNamedOperand(MISucc, AMDGPU::OpName::src0))
910*da58b97aSjoerg .add(*TII->getNamedOperand(MISucc, AMDGPU::OpName::src1))
911*da58b97aSjoerg .setMIFlags(MISucc.getFlags());
912*da58b97aSjoerg
91306f32e7eSjoerg MISucc.eraseFromParent();
91406f32e7eSjoerg }
91506f32e7eSjoerg
isConvertibleToSDWA(MachineInstr & MI,const GCNSubtarget & ST) const91606f32e7eSjoerg bool SIPeepholeSDWA::isConvertibleToSDWA(MachineInstr &MI,
91706f32e7eSjoerg const GCNSubtarget &ST) const {
91806f32e7eSjoerg // Check if this is already an SDWA instruction
91906f32e7eSjoerg unsigned Opc = MI.getOpcode();
92006f32e7eSjoerg if (TII->isSDWA(Opc))
92106f32e7eSjoerg return true;
92206f32e7eSjoerg
92306f32e7eSjoerg // Check if this instruction has opcode that supports SDWA
92406f32e7eSjoerg if (AMDGPU::getSDWAOp(Opc) == -1)
92506f32e7eSjoerg Opc = AMDGPU::getVOPe32(Opc);
92606f32e7eSjoerg
92706f32e7eSjoerg if (AMDGPU::getSDWAOp(Opc) == -1)
92806f32e7eSjoerg return false;
92906f32e7eSjoerg
93006f32e7eSjoerg if (!ST.hasSDWAOmod() && TII->hasModifiersSet(MI, AMDGPU::OpName::omod))
93106f32e7eSjoerg return false;
93206f32e7eSjoerg
93306f32e7eSjoerg if (TII->isVOPC(Opc)) {
93406f32e7eSjoerg if (!ST.hasSDWASdst()) {
93506f32e7eSjoerg const MachineOperand *SDst = TII->getNamedOperand(MI, AMDGPU::OpName::sdst);
93606f32e7eSjoerg if (SDst && (SDst->getReg() != AMDGPU::VCC &&
93706f32e7eSjoerg SDst->getReg() != AMDGPU::VCC_LO))
93806f32e7eSjoerg return false;
93906f32e7eSjoerg }
94006f32e7eSjoerg
94106f32e7eSjoerg if (!ST.hasSDWAOutModsVOPC() &&
94206f32e7eSjoerg (TII->hasModifiersSet(MI, AMDGPU::OpName::clamp) ||
94306f32e7eSjoerg TII->hasModifiersSet(MI, AMDGPU::OpName::omod)))
94406f32e7eSjoerg return false;
94506f32e7eSjoerg
94606f32e7eSjoerg } else if (TII->getNamedOperand(MI, AMDGPU::OpName::sdst) ||
94706f32e7eSjoerg !TII->getNamedOperand(MI, AMDGPU::OpName::vdst)) {
94806f32e7eSjoerg return false;
94906f32e7eSjoerg }
95006f32e7eSjoerg
95106f32e7eSjoerg if (!ST.hasSDWAMac() && (Opc == AMDGPU::V_FMAC_F16_e32 ||
95206f32e7eSjoerg Opc == AMDGPU::V_FMAC_F32_e32 ||
95306f32e7eSjoerg Opc == AMDGPU::V_MAC_F16_e32 ||
95406f32e7eSjoerg Opc == AMDGPU::V_MAC_F32_e32))
95506f32e7eSjoerg return false;
95606f32e7eSjoerg
95706f32e7eSjoerg // Check if target supports this SDWA opcode
95806f32e7eSjoerg if (TII->pseudoToMCOpcode(Opc) == -1)
95906f32e7eSjoerg return false;
96006f32e7eSjoerg
96106f32e7eSjoerg // FIXME: has SDWA but require handling of implicit VCC use
96206f32e7eSjoerg if (Opc == AMDGPU::V_CNDMASK_B32_e32)
96306f32e7eSjoerg return false;
96406f32e7eSjoerg
965*da58b97aSjoerg if (MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0)) {
966*da58b97aSjoerg if (!Src0->isReg() && !Src0->isImm())
967*da58b97aSjoerg return false;
968*da58b97aSjoerg }
969*da58b97aSjoerg
970*da58b97aSjoerg if (MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1)) {
971*da58b97aSjoerg if (!Src1->isReg() && !Src1->isImm())
972*da58b97aSjoerg return false;
973*da58b97aSjoerg }
974*da58b97aSjoerg
97506f32e7eSjoerg return true;
97606f32e7eSjoerg }
97706f32e7eSjoerg
convertToSDWA(MachineInstr & MI,const SDWAOperandsVector & SDWAOperands)97806f32e7eSjoerg bool SIPeepholeSDWA::convertToSDWA(MachineInstr &MI,
97906f32e7eSjoerg const SDWAOperandsVector &SDWAOperands) {
98006f32e7eSjoerg
98106f32e7eSjoerg LLVM_DEBUG(dbgs() << "Convert instruction:" << MI);
98206f32e7eSjoerg
98306f32e7eSjoerg // Convert to sdwa
98406f32e7eSjoerg int SDWAOpcode;
98506f32e7eSjoerg unsigned Opcode = MI.getOpcode();
98606f32e7eSjoerg if (TII->isSDWA(Opcode)) {
98706f32e7eSjoerg SDWAOpcode = Opcode;
98806f32e7eSjoerg } else {
98906f32e7eSjoerg SDWAOpcode = AMDGPU::getSDWAOp(Opcode);
99006f32e7eSjoerg if (SDWAOpcode == -1)
99106f32e7eSjoerg SDWAOpcode = AMDGPU::getSDWAOp(AMDGPU::getVOPe32(Opcode));
99206f32e7eSjoerg }
99306f32e7eSjoerg assert(SDWAOpcode != -1);
99406f32e7eSjoerg
99506f32e7eSjoerg const MCInstrDesc &SDWADesc = TII->get(SDWAOpcode);
99606f32e7eSjoerg
99706f32e7eSjoerg // Create SDWA version of instruction MI and initialize its operands
99806f32e7eSjoerg MachineInstrBuilder SDWAInst =
999*da58b97aSjoerg BuildMI(*MI.getParent(), MI, MI.getDebugLoc(), SDWADesc)
1000*da58b97aSjoerg .setMIFlags(MI.getFlags());
100106f32e7eSjoerg
100206f32e7eSjoerg // Copy dst, if it is present in original then should also be present in SDWA
100306f32e7eSjoerg MachineOperand *Dst = TII->getNamedOperand(MI, AMDGPU::OpName::vdst);
100406f32e7eSjoerg if (Dst) {
100506f32e7eSjoerg assert(AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::vdst) != -1);
100606f32e7eSjoerg SDWAInst.add(*Dst);
100706f32e7eSjoerg } else if ((Dst = TII->getNamedOperand(MI, AMDGPU::OpName::sdst))) {
100806f32e7eSjoerg assert(Dst &&
100906f32e7eSjoerg AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::sdst) != -1);
101006f32e7eSjoerg SDWAInst.add(*Dst);
101106f32e7eSjoerg } else {
101206f32e7eSjoerg assert(AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::sdst) != -1);
101306f32e7eSjoerg SDWAInst.addReg(TRI->getVCC(), RegState::Define);
101406f32e7eSjoerg }
101506f32e7eSjoerg
101606f32e7eSjoerg // Copy src0, initialize src0_modifiers. All sdwa instructions has src0 and
101706f32e7eSjoerg // src0_modifiers (except for v_nop_sdwa, but it can't get here)
101806f32e7eSjoerg MachineOperand *Src0 = TII->getNamedOperand(MI, AMDGPU::OpName::src0);
101906f32e7eSjoerg assert(
102006f32e7eSjoerg Src0 &&
102106f32e7eSjoerg AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src0) != -1 &&
102206f32e7eSjoerg AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src0_modifiers) != -1);
102306f32e7eSjoerg if (auto *Mod = TII->getNamedOperand(MI, AMDGPU::OpName::src0_modifiers))
102406f32e7eSjoerg SDWAInst.addImm(Mod->getImm());
102506f32e7eSjoerg else
102606f32e7eSjoerg SDWAInst.addImm(0);
102706f32e7eSjoerg SDWAInst.add(*Src0);
102806f32e7eSjoerg
102906f32e7eSjoerg // Copy src1 if present, initialize src1_modifiers.
103006f32e7eSjoerg MachineOperand *Src1 = TII->getNamedOperand(MI, AMDGPU::OpName::src1);
103106f32e7eSjoerg if (Src1) {
103206f32e7eSjoerg assert(
103306f32e7eSjoerg AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src1) != -1 &&
103406f32e7eSjoerg AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src1_modifiers) != -1);
103506f32e7eSjoerg if (auto *Mod = TII->getNamedOperand(MI, AMDGPU::OpName::src1_modifiers))
103606f32e7eSjoerg SDWAInst.addImm(Mod->getImm());
103706f32e7eSjoerg else
103806f32e7eSjoerg SDWAInst.addImm(0);
103906f32e7eSjoerg SDWAInst.add(*Src1);
104006f32e7eSjoerg }
104106f32e7eSjoerg
104206f32e7eSjoerg if (SDWAOpcode == AMDGPU::V_FMAC_F16_sdwa ||
104306f32e7eSjoerg SDWAOpcode == AMDGPU::V_FMAC_F32_sdwa ||
104406f32e7eSjoerg SDWAOpcode == AMDGPU::V_MAC_F16_sdwa ||
104506f32e7eSjoerg SDWAOpcode == AMDGPU::V_MAC_F32_sdwa) {
104606f32e7eSjoerg // v_mac_f16/32 has additional src2 operand tied to vdst
104706f32e7eSjoerg MachineOperand *Src2 = TII->getNamedOperand(MI, AMDGPU::OpName::src2);
104806f32e7eSjoerg assert(Src2);
104906f32e7eSjoerg SDWAInst.add(*Src2);
105006f32e7eSjoerg }
105106f32e7eSjoerg
105206f32e7eSjoerg // Copy clamp if present, initialize otherwise
105306f32e7eSjoerg assert(AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::clamp) != -1);
105406f32e7eSjoerg MachineOperand *Clamp = TII->getNamedOperand(MI, AMDGPU::OpName::clamp);
105506f32e7eSjoerg if (Clamp) {
105606f32e7eSjoerg SDWAInst.add(*Clamp);
105706f32e7eSjoerg } else {
105806f32e7eSjoerg SDWAInst.addImm(0);
105906f32e7eSjoerg }
106006f32e7eSjoerg
106106f32e7eSjoerg // Copy omod if present, initialize otherwise if needed
106206f32e7eSjoerg if (AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::omod) != -1) {
106306f32e7eSjoerg MachineOperand *OMod = TII->getNamedOperand(MI, AMDGPU::OpName::omod);
106406f32e7eSjoerg if (OMod) {
106506f32e7eSjoerg SDWAInst.add(*OMod);
106606f32e7eSjoerg } else {
106706f32e7eSjoerg SDWAInst.addImm(0);
106806f32e7eSjoerg }
106906f32e7eSjoerg }
107006f32e7eSjoerg
107106f32e7eSjoerg // Copy dst_sel if present, initialize otherwise if needed
107206f32e7eSjoerg if (AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::dst_sel) != -1) {
107306f32e7eSjoerg MachineOperand *DstSel = TII->getNamedOperand(MI, AMDGPU::OpName::dst_sel);
107406f32e7eSjoerg if (DstSel) {
107506f32e7eSjoerg SDWAInst.add(*DstSel);
107606f32e7eSjoerg } else {
107706f32e7eSjoerg SDWAInst.addImm(AMDGPU::SDWA::SdwaSel::DWORD);
107806f32e7eSjoerg }
107906f32e7eSjoerg }
108006f32e7eSjoerg
108106f32e7eSjoerg // Copy dst_unused if present, initialize otherwise if needed
108206f32e7eSjoerg if (AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::dst_unused) != -1) {
108306f32e7eSjoerg MachineOperand *DstUnused = TII->getNamedOperand(MI, AMDGPU::OpName::dst_unused);
108406f32e7eSjoerg if (DstUnused) {
108506f32e7eSjoerg SDWAInst.add(*DstUnused);
108606f32e7eSjoerg } else {
108706f32e7eSjoerg SDWAInst.addImm(AMDGPU::SDWA::DstUnused::UNUSED_PAD);
108806f32e7eSjoerg }
108906f32e7eSjoerg }
109006f32e7eSjoerg
109106f32e7eSjoerg // Copy src0_sel if present, initialize otherwise
109206f32e7eSjoerg assert(AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src0_sel) != -1);
109306f32e7eSjoerg MachineOperand *Src0Sel = TII->getNamedOperand(MI, AMDGPU::OpName::src0_sel);
109406f32e7eSjoerg if (Src0Sel) {
109506f32e7eSjoerg SDWAInst.add(*Src0Sel);
109606f32e7eSjoerg } else {
109706f32e7eSjoerg SDWAInst.addImm(AMDGPU::SDWA::SdwaSel::DWORD);
109806f32e7eSjoerg }
109906f32e7eSjoerg
110006f32e7eSjoerg // Copy src1_sel if present, initialize otherwise if needed
110106f32e7eSjoerg if (Src1) {
110206f32e7eSjoerg assert(AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::src1_sel) != -1);
110306f32e7eSjoerg MachineOperand *Src1Sel = TII->getNamedOperand(MI, AMDGPU::OpName::src1_sel);
110406f32e7eSjoerg if (Src1Sel) {
110506f32e7eSjoerg SDWAInst.add(*Src1Sel);
110606f32e7eSjoerg } else {
110706f32e7eSjoerg SDWAInst.addImm(AMDGPU::SDWA::SdwaSel::DWORD);
110806f32e7eSjoerg }
110906f32e7eSjoerg }
111006f32e7eSjoerg
111106f32e7eSjoerg // Check for a preserved register that needs to be copied.
111206f32e7eSjoerg auto DstUnused = TII->getNamedOperand(MI, AMDGPU::OpName::dst_unused);
111306f32e7eSjoerg if (DstUnused &&
111406f32e7eSjoerg DstUnused->getImm() == AMDGPU::SDWA::DstUnused::UNUSED_PRESERVE) {
111506f32e7eSjoerg // We expect, if we are here, that the instruction was already in it's SDWA form,
111606f32e7eSjoerg // with a tied operand.
111706f32e7eSjoerg assert(Dst && Dst->isTied());
111806f32e7eSjoerg assert(Opcode == static_cast<unsigned int>(SDWAOpcode));
111906f32e7eSjoerg // We also expect a vdst, since sdst can't preserve.
112006f32e7eSjoerg auto PreserveDstIdx = AMDGPU::getNamedOperandIdx(SDWAOpcode, AMDGPU::OpName::vdst);
112106f32e7eSjoerg assert(PreserveDstIdx != -1);
112206f32e7eSjoerg
112306f32e7eSjoerg auto TiedIdx = MI.findTiedOperandIdx(PreserveDstIdx);
112406f32e7eSjoerg auto Tied = MI.getOperand(TiedIdx);
112506f32e7eSjoerg
112606f32e7eSjoerg SDWAInst.add(Tied);
112706f32e7eSjoerg SDWAInst->tieOperands(PreserveDstIdx, SDWAInst->getNumOperands() - 1);
112806f32e7eSjoerg }
112906f32e7eSjoerg
113006f32e7eSjoerg // Apply all sdwa operand patterns.
113106f32e7eSjoerg bool Converted = false;
113206f32e7eSjoerg for (auto &Operand : SDWAOperands) {
113306f32e7eSjoerg LLVM_DEBUG(dbgs() << *SDWAInst << "\nOperand: " << *Operand);
113406f32e7eSjoerg // There should be no intesection between SDWA operands and potential MIs
113506f32e7eSjoerg // e.g.:
113606f32e7eSjoerg // v_and_b32 v0, 0xff, v1 -> src:v1 sel:BYTE_0
113706f32e7eSjoerg // v_and_b32 v2, 0xff, v0 -> src:v0 sel:BYTE_0
113806f32e7eSjoerg // v_add_u32 v3, v4, v2
113906f32e7eSjoerg //
114006f32e7eSjoerg // In that example it is possible that we would fold 2nd instruction into 3rd
114106f32e7eSjoerg // (v_add_u32_sdwa) and then try to fold 1st instruction into 2nd (that was
114206f32e7eSjoerg // already destroyed). So if SDWAOperand is also a potential MI then do not
114306f32e7eSjoerg // apply it.
114406f32e7eSjoerg if (PotentialMatches.count(Operand->getParentInst()) == 0)
114506f32e7eSjoerg Converted |= Operand->convertToSDWA(*SDWAInst, TII);
114606f32e7eSjoerg }
114706f32e7eSjoerg if (Converted) {
114806f32e7eSjoerg ConvertedInstructions.push_back(SDWAInst);
114906f32e7eSjoerg } else {
115006f32e7eSjoerg SDWAInst->eraseFromParent();
115106f32e7eSjoerg return false;
115206f32e7eSjoerg }
115306f32e7eSjoerg
115406f32e7eSjoerg LLVM_DEBUG(dbgs() << "\nInto:" << *SDWAInst << '\n');
115506f32e7eSjoerg ++NumSDWAInstructionsPeepholed;
115606f32e7eSjoerg
115706f32e7eSjoerg MI.eraseFromParent();
115806f32e7eSjoerg return true;
115906f32e7eSjoerg }
116006f32e7eSjoerg
116106f32e7eSjoerg // If an instruction was converted to SDWA it should not have immediates or SGPR
116206f32e7eSjoerg // operands (allowed one SGPR on GFX9). Copy its scalar operands into VGPRs.
legalizeScalarOperands(MachineInstr & MI,const GCNSubtarget & ST) const116306f32e7eSjoerg void SIPeepholeSDWA::legalizeScalarOperands(MachineInstr &MI,
116406f32e7eSjoerg const GCNSubtarget &ST) const {
116506f32e7eSjoerg const MCInstrDesc &Desc = TII->get(MI.getOpcode());
116606f32e7eSjoerg unsigned ConstantBusCount = 0;
116706f32e7eSjoerg for (MachineOperand &Op : MI.explicit_uses()) {
116806f32e7eSjoerg if (!Op.isImm() && !(Op.isReg() && !TRI->isVGPR(*MRI, Op.getReg())))
116906f32e7eSjoerg continue;
117006f32e7eSjoerg
117106f32e7eSjoerg unsigned I = MI.getOperandNo(&Op);
117206f32e7eSjoerg if (Desc.OpInfo[I].RegClass == -1 ||
117306f32e7eSjoerg !TRI->hasVGPRs(TRI->getRegClass(Desc.OpInfo[I].RegClass)))
117406f32e7eSjoerg continue;
117506f32e7eSjoerg
117606f32e7eSjoerg if (ST.hasSDWAScalar() && ConstantBusCount == 0 && Op.isReg() &&
117706f32e7eSjoerg TRI->isSGPRReg(*MRI, Op.getReg())) {
117806f32e7eSjoerg ++ConstantBusCount;
117906f32e7eSjoerg continue;
118006f32e7eSjoerg }
118106f32e7eSjoerg
118206f32e7eSjoerg Register VGPR = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass);
118306f32e7eSjoerg auto Copy = BuildMI(*MI.getParent(), MI.getIterator(), MI.getDebugLoc(),
118406f32e7eSjoerg TII->get(AMDGPU::V_MOV_B32_e32), VGPR);
118506f32e7eSjoerg if (Op.isImm())
118606f32e7eSjoerg Copy.addImm(Op.getImm());
118706f32e7eSjoerg else if (Op.isReg())
118806f32e7eSjoerg Copy.addReg(Op.getReg(), Op.isKill() ? RegState::Kill : 0,
118906f32e7eSjoerg Op.getSubReg());
119006f32e7eSjoerg Op.ChangeToRegister(VGPR, false);
119106f32e7eSjoerg }
119206f32e7eSjoerg }
119306f32e7eSjoerg
runOnMachineFunction(MachineFunction & MF)119406f32e7eSjoerg bool SIPeepholeSDWA::runOnMachineFunction(MachineFunction &MF) {
119506f32e7eSjoerg const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
119606f32e7eSjoerg
119706f32e7eSjoerg if (!ST.hasSDWA() || skipFunction(MF.getFunction()))
119806f32e7eSjoerg return false;
119906f32e7eSjoerg
120006f32e7eSjoerg MRI = &MF.getRegInfo();
120106f32e7eSjoerg TRI = ST.getRegisterInfo();
120206f32e7eSjoerg TII = ST.getInstrInfo();
120306f32e7eSjoerg
120406f32e7eSjoerg // Find all SDWA operands in MF.
120506f32e7eSjoerg bool Ret = false;
120606f32e7eSjoerg for (MachineBasicBlock &MBB : MF) {
120706f32e7eSjoerg bool Changed = false;
120806f32e7eSjoerg do {
120906f32e7eSjoerg // Preprocess the ADD/SUB pairs so they could be SDWA'ed.
121006f32e7eSjoerg // Look for a possible ADD or SUB that resulted from a previously lowered
121106f32e7eSjoerg // V_{ADD|SUB}_U64_PSEUDO. The function pseudoOpConvertToVOP2
121206f32e7eSjoerg // lowers the pair of instructions into e32 form.
121306f32e7eSjoerg matchSDWAOperands(MBB);
121406f32e7eSjoerg for (const auto &OperandPair : SDWAOperands) {
121506f32e7eSjoerg const auto &Operand = OperandPair.second;
121606f32e7eSjoerg MachineInstr *PotentialMI = Operand->potentialToConvert(TII);
121706f32e7eSjoerg if (PotentialMI &&
1218*da58b97aSjoerg (PotentialMI->getOpcode() == AMDGPU::V_ADD_CO_U32_e64 ||
1219*da58b97aSjoerg PotentialMI->getOpcode() == AMDGPU::V_SUB_CO_U32_e64))
122006f32e7eSjoerg pseudoOpConvertToVOP2(*PotentialMI, ST);
122106f32e7eSjoerg }
122206f32e7eSjoerg SDWAOperands.clear();
122306f32e7eSjoerg
122406f32e7eSjoerg // Generate potential match list.
122506f32e7eSjoerg matchSDWAOperands(MBB);
122606f32e7eSjoerg
122706f32e7eSjoerg for (const auto &OperandPair : SDWAOperands) {
122806f32e7eSjoerg const auto &Operand = OperandPair.second;
122906f32e7eSjoerg MachineInstr *PotentialMI = Operand->potentialToConvert(TII);
123006f32e7eSjoerg if (PotentialMI && isConvertibleToSDWA(*PotentialMI, ST)) {
123106f32e7eSjoerg PotentialMatches[PotentialMI].push_back(Operand.get());
123206f32e7eSjoerg }
123306f32e7eSjoerg }
123406f32e7eSjoerg
123506f32e7eSjoerg for (auto &PotentialPair : PotentialMatches) {
123606f32e7eSjoerg MachineInstr &PotentialMI = *PotentialPair.first;
123706f32e7eSjoerg convertToSDWA(PotentialMI, PotentialPair.second);
123806f32e7eSjoerg }
123906f32e7eSjoerg
124006f32e7eSjoerg PotentialMatches.clear();
124106f32e7eSjoerg SDWAOperands.clear();
124206f32e7eSjoerg
124306f32e7eSjoerg Changed = !ConvertedInstructions.empty();
124406f32e7eSjoerg
124506f32e7eSjoerg if (Changed)
124606f32e7eSjoerg Ret = true;
124706f32e7eSjoerg while (!ConvertedInstructions.empty())
124806f32e7eSjoerg legalizeScalarOperands(*ConvertedInstructions.pop_back_val(), ST);
124906f32e7eSjoerg } while (Changed);
125006f32e7eSjoerg }
125106f32e7eSjoerg
125206f32e7eSjoerg return Ret;
125306f32e7eSjoerg }
1254