1//===- GCNCreateVOPD.cpp - Create VOPD Instructions ----------------------===//
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/// Combine VALU pairs into VOPD instructions
11/// Only works on wave32
12/// Has register requirements, we reject creating VOPD if the requirements are
13/// not met.
14/// shouldCombineVOPD mutator in postRA machine scheduler puts candidate
15/// instructions for VOPD back-to-back
16///
17//
18//===----------------------------------------------------------------------===//
19
20#include "AMDGPU.h"
21#include "GCNSubtarget.h"
22#include "GCNVOPDUtils.h"
23#include "MCTargetDesc/AMDGPUMCTargetDesc.h"
24#include "SIInstrInfo.h"
25#include "Utils/AMDGPUBaseInfo.h"
26#include "llvm/ADT/SmallVector.h"
27#include "llvm/ADT/Statistic.h"
28#include "llvm/CodeGen/MachineBasicBlock.h"
29#include "llvm/CodeGen/MachineInstr.h"
30#include "llvm/CodeGen/MachineOperand.h"
31#include "llvm/Support/Casting.h"
32#include "llvm/Support/Debug.h"
33#include <utility>
34
35#define DEBUG_TYPE "gcn-create-vopd"
36STATISTIC(NumVOPDCreated, "Number of VOPD Insts Created.");
37
38using namespace llvm;
39
40namespace {
41
42class GCNCreateVOPD : public MachineFunctionPass {
43private:
44    class VOPDCombineInfo {
45    public:
46      VOPDCombineInfo() {}
47      VOPDCombineInfo(MachineInstr *First, MachineInstr *Second)
48          : FirstMI(First), SecondMI(Second) {}
49
50      MachineInstr *FirstMI;
51      MachineInstr *SecondMI;
52    };
53
54public:
55  static char ID;
56  const GCNSubtarget *ST = nullptr;
57
58  GCNCreateVOPD() : MachineFunctionPass(ID) {}
59
60  void getAnalysisUsage(AnalysisUsage &AU) const override {
61    AU.setPreservesCFG();
62    MachineFunctionPass::getAnalysisUsage(AU);
63  }
64
65  StringRef getPassName() const override {
66    return "GCN Create VOPD Instructions";
67  }
68
69  bool doReplace(const SIInstrInfo *SII, VOPDCombineInfo &CI) {
70    auto *FirstMI = CI.FirstMI;
71    auto *SecondMI = CI.SecondMI;
72    unsigned Opc1 = FirstMI->getOpcode();
73    unsigned Opc2 = SecondMI->getOpcode();
74    unsigned EncodingFamily =
75        AMDGPU::getVOPDEncodingFamily(SII->getSubtarget());
76    int NewOpcode =
77        AMDGPU::getVOPDFull(AMDGPU::getVOPDOpcode(Opc1),
78                            AMDGPU::getVOPDOpcode(Opc2), EncodingFamily);
79    assert(NewOpcode != -1 &&
80           "Should have previously determined this as a possible VOPD\n");
81
82    auto VOPDInst = BuildMI(*FirstMI->getParent(), FirstMI,
83                            FirstMI->getDebugLoc(), SII->get(NewOpcode))
84                        .setMIFlags(FirstMI->getFlags() | SecondMI->getFlags());
85
86    namespace VOPD = AMDGPU::VOPD;
87    MachineInstr *MI[] = {FirstMI, SecondMI};
88    auto InstInfo =
89        AMDGPU::getVOPDInstInfo(FirstMI->getDesc(), SecondMI->getDesc());
90
91    for (auto CompIdx : VOPD::COMPONENTS) {
92      auto MCOprIdx = InstInfo[CompIdx].getIndexOfDstInMCOperands();
93      VOPDInst.add(MI[CompIdx]->getOperand(MCOprIdx));
94    }
95
96    for (auto CompIdx : VOPD::COMPONENTS) {
97      auto CompSrcOprNum = InstInfo[CompIdx].getCompSrcOperandsNum();
98      for (unsigned CompSrcIdx = 0; CompSrcIdx < CompSrcOprNum; ++CompSrcIdx) {
99        auto MCOprIdx = InstInfo[CompIdx].getIndexOfSrcInMCOperands(CompSrcIdx);
100        VOPDInst.add(MI[CompIdx]->getOperand(MCOprIdx));
101      }
102    }
103
104    for (auto CompIdx : VOPD::COMPONENTS)
105      VOPDInst.copyImplicitOps(*MI[CompIdx]);
106
107    LLVM_DEBUG(dbgs() << "VOPD Fused: " << *VOPDInst << " from\tX: "
108                      << *CI.FirstMI << "\tY: " << *CI.SecondMI << "\n");
109
110    for (auto CompIdx : VOPD::COMPONENTS)
111      MI[CompIdx]->eraseFromParent();
112
113    ++NumVOPDCreated;
114    return true;
115  }
116
117  bool runOnMachineFunction(MachineFunction &MF) override {
118    if (skipFunction(MF.getFunction()))
119      return false;
120    ST = &MF.getSubtarget<GCNSubtarget>();
121    if (!AMDGPU::hasVOPD(*ST) || !ST->isWave32())
122      return false;
123    LLVM_DEBUG(dbgs() << "CreateVOPD Pass:\n");
124
125    const SIInstrInfo *SII = ST->getInstrInfo();
126    bool Changed = false;
127
128    SmallVector<VOPDCombineInfo> ReplaceCandidates;
129
130    for (auto &MBB : MF) {
131      auto MII = MBB.begin(), E = MBB.end();
132      while (MII != E) {
133        auto *FirstMI = &*MII;
134        MII = next_nodbg(MII, MBB.end());
135        if (MII == MBB.end())
136          break;
137        if (FirstMI->isDebugInstr())
138          continue;
139        auto *SecondMI = &*MII;
140        unsigned Opc = FirstMI->getOpcode();
141        unsigned Opc2 = SecondMI->getOpcode();
142        llvm::AMDGPU::CanBeVOPD FirstCanBeVOPD = AMDGPU::getCanBeVOPD(Opc);
143        llvm::AMDGPU::CanBeVOPD SecondCanBeVOPD = AMDGPU::getCanBeVOPD(Opc2);
144        VOPDCombineInfo CI;
145
146        if (FirstCanBeVOPD.X && SecondCanBeVOPD.Y)
147          CI = VOPDCombineInfo(FirstMI, SecondMI);
148        else if (FirstCanBeVOPD.Y && SecondCanBeVOPD.X)
149          CI = VOPDCombineInfo(SecondMI, FirstMI);
150        else
151          continue;
152        // checkVOPDRegConstraints cares about program order, but doReplace
153        // cares about X-Y order in the constituted VOPD
154        if (llvm::checkVOPDRegConstraints(*SII, *FirstMI, *SecondMI)) {
155          ReplaceCandidates.push_back(CI);
156          ++MII;
157        }
158      }
159    }
160    for (auto &CI : ReplaceCandidates) {
161      Changed |= doReplace(SII, CI);
162    }
163
164    return Changed;
165  }
166};
167
168} // namespace
169
170char GCNCreateVOPD::ID = 0;
171
172char &llvm::GCNCreateVOPDID = GCNCreateVOPD::ID;
173
174INITIALIZE_PASS(GCNCreateVOPD, DEBUG_TYPE, "GCN Create VOPD Instructions",
175                false, false)
176