1 //===- llvm/CodeGen/GlobalISel/InstructionSelect.cpp - InstructionSelect ---==//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// This file implements the InstructionSelect class.
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
14 #include "llvm/ADT/PostOrderIterator.h"
15 #include "llvm/ADT/Twine.h"
16 #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
17 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
18 #include "llvm/CodeGen/GlobalISel/Utils.h"
19 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
20 #include "llvm/CodeGen/MachineRegisterInfo.h"
21 #include "llvm/CodeGen/TargetLowering.h"
22 #include "llvm/CodeGen/TargetPassConfig.h"
23 #include "llvm/CodeGen/TargetSubtargetInfo.h"
24 #include "llvm/Config/config.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/Support/CommandLine.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/TargetRegistry.h"
30 
31 #define DEBUG_TYPE "instruction-select"
32 
33 using namespace llvm;
34 
35 #ifdef LLVM_GISEL_COV_PREFIX
36 static cl::opt<std::string>
37     CoveragePrefix("gisel-coverage-prefix", cl::init(LLVM_GISEL_COV_PREFIX),
38                    cl::desc("Record GlobalISel rule coverage files of this "
39                             "prefix if instrumentation was generated"));
40 #else
41 static const std::string CoveragePrefix = "";
42 #endif
43 
44 char InstructionSelect::ID = 0;
45 INITIALIZE_PASS_BEGIN(InstructionSelect, DEBUG_TYPE,
46                       "Select target instructions out of generic instructions",
47                       false, false)
48 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
49 INITIALIZE_PASS_END(InstructionSelect, DEBUG_TYPE,
50                     "Select target instructions out of generic instructions",
51                     false, false)
52 
53 InstructionSelect::InstructionSelect() : MachineFunctionPass(ID) {
54   initializeInstructionSelectPass(*PassRegistry::getPassRegistry());
55 }
56 
57 void InstructionSelect::getAnalysisUsage(AnalysisUsage &AU) const {
58   AU.addRequired<TargetPassConfig>();
59   MachineFunctionPass::getAnalysisUsage(AU);
60 }
61 
62 bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {
63   // If the ISel pipeline failed, do not bother running that pass.
64   if (MF.getProperties().hasProperty(
65           MachineFunctionProperties::Property::FailedISel))
66     return false;
67 
68   DEBUG(dbgs() << "Selecting function: " << MF.getName() << '\n');
69 
70   const TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
71   const InstructionSelector *ISel = MF.getSubtarget().getInstructionSelector();
72   CodeGenCoverage CoverageInfo;
73   assert(ISel && "Cannot work without InstructionSelector");
74 
75   // An optimization remark emitter. Used to report failures.
76   MachineOptimizationRemarkEmitter MORE(MF, /*MBFI=*/nullptr);
77 
78   // FIXME: There are many other MF/MFI fields we need to initialize.
79 
80   const MachineRegisterInfo &MRI = MF.getRegInfo();
81 #ifndef NDEBUG
82   // Check that our input is fully legal: we require the function to have the
83   // Legalized property, so it should be.
84   // FIXME: This should be in the MachineVerifier, as the RegBankSelected
85   // property check already is.
86   if (!DisableGISelLegalityCheck)
87     if (const MachineInstr *MI = machineFunctionIsIllegal(MF)) {
88       reportGISelFailure(MF, TPC, MORE, "gisel-select",
89                          "instruction is not legal", *MI);
90       return false;
91     }
92 #endif
93   // FIXME: We could introduce new blocks and will need to fix the outer loop.
94   // Until then, keep track of the number of blocks to assert that we don't.
95   const size_t NumBlocks = MF.size();
96 
97   for (MachineBasicBlock *MBB : post_order(&MF)) {
98     if (MBB->empty())
99       continue;
100 
101     // Select instructions in reverse block order. We permit erasing so have
102     // to resort to manually iterating and recognizing the begin (rend) case.
103     bool ReachedBegin = false;
104     for (auto MII = std::prev(MBB->end()), Begin = MBB->begin();
105          !ReachedBegin;) {
106 #ifndef NDEBUG
107       // Keep track of the insertion range for debug printing.
108       const auto AfterIt = std::next(MII);
109 #endif
110       // Select this instruction.
111       MachineInstr &MI = *MII;
112 
113       // And have our iterator point to the next instruction, if there is one.
114       if (MII == Begin)
115         ReachedBegin = true;
116       else
117         --MII;
118 
119       DEBUG(dbgs() << "Selecting: \n  " << MI);
120 
121       // We could have folded this instruction away already, making it dead.
122       // If so, erase it.
123       if (isTriviallyDead(MI, MRI)) {
124         DEBUG(dbgs() << "Is dead; erasing.\n");
125         MI.eraseFromParentAndMarkDBGValuesForRemoval();
126         continue;
127       }
128 
129       if (!ISel->select(MI, CoverageInfo)) {
130         // FIXME: It would be nice to dump all inserted instructions.  It's
131         // not obvious how, esp. considering select() can insert after MI.
132         reportGISelFailure(MF, TPC, MORE, "gisel-select", "cannot select", MI);
133         return false;
134       }
135 
136       // Dump the range of instructions that MI expanded into.
137       DEBUG({
138         auto InsertedBegin = ReachedBegin ? MBB->begin() : std::next(MII);
139         dbgs() << "Into:\n";
140         for (auto &InsertedMI : make_range(InsertedBegin, AfterIt))
141           dbgs() << "  " << InsertedMI;
142         dbgs() << '\n';
143       });
144     }
145   }
146 
147   const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
148 
149   for (MachineBasicBlock &MBB : MF) {
150     if (MBB.empty())
151       continue;
152 
153     // Try to find redundant copies b/w vregs of the same register class.
154     bool ReachedBegin = false;
155     for (auto MII = std::prev(MBB.end()), Begin = MBB.begin(); !ReachedBegin;) {
156       // Select this instruction.
157       MachineInstr &MI = *MII;
158 
159       // And have our iterator point to the next instruction, if there is one.
160       if (MII == Begin)
161         ReachedBegin = true;
162       else
163         --MII;
164       if (MI.getOpcode() != TargetOpcode::COPY)
165         continue;
166       unsigned SrcReg = MI.getOperand(1).getReg();
167       unsigned DstReg = MI.getOperand(0).getReg();
168       if (TargetRegisterInfo::isVirtualRegister(SrcReg) &&
169           TargetRegisterInfo::isVirtualRegister(DstReg)) {
170         MachineRegisterInfo &MRI = MF.getRegInfo();
171         auto SrcRC = MRI.getRegClass(SrcReg);
172         auto DstRC = MRI.getRegClass(DstReg);
173         if (SrcRC == DstRC) {
174           MRI.replaceRegWith(DstReg, SrcReg);
175           MI.eraseFromParentAndMarkDBGValuesForRemoval();
176         }
177       }
178     }
179   }
180 
181   // Now that selection is complete, there are no more generic vregs.  Verify
182   // that the size of the now-constrained vreg is unchanged and that it has a
183   // register class.
184   for (auto &VRegToType : MRI.getVRegToType()) {
185     unsigned VReg = VRegToType.first;
186     auto *RC = MRI.getRegClassOrNull(VReg);
187     MachineInstr *MI = nullptr;
188     if (!MRI.def_empty(VReg))
189       MI = &*MRI.def_instr_begin(VReg);
190     else if (!MRI.use_empty(VReg))
191       MI = &*MRI.use_instr_begin(VReg);
192 
193     if (MI && !RC) {
194       reportGISelFailure(MF, TPC, MORE, "gisel-select",
195                          "VReg has no regclass after selection", *MI);
196       return false;
197     } else if (!RC)
198       continue;
199 
200     if (VRegToType.second.isValid() &&
201         VRegToType.second.getSizeInBits() > TRI.getRegSizeInBits(*RC)) {
202       reportGISelFailure(MF, TPC, MORE, "gisel-select",
203                          "VReg has explicit size different from class size",
204                          *MI);
205       return false;
206     }
207   }
208 
209   if (MF.size() != NumBlocks) {
210     MachineOptimizationRemarkMissed R("gisel-select", "GISelFailure",
211                                       MF.getFunction().getSubprogram(),
212                                       /*MBB=*/nullptr);
213     R << "inserting blocks is not supported yet";
214     reportGISelFailure(MF, TPC, MORE, R);
215     return false;
216   }
217 
218   auto &TLI = *MF.getSubtarget().getTargetLowering();
219   TLI.finalizeLowering(MF);
220 
221   CoverageInfo.emit(CoveragePrefix,
222                     MF.getSubtarget()
223                         .getTargetLowering()
224                         ->getTargetMachine()
225                         .getTarget()
226                         .getBackendName());
227 
228   // If we successfully selected the function nothing is going to use the vreg
229   // types after us (otherwise MIRPrinter would need them). Make sure the types
230   // disappear.
231   MRI.getVRegToType().clear();
232 
233   // FIXME: Should we accurately track changes?
234   return true;
235 }
236