1 //===-- MVEVPTBlockPass.cpp - Insert MVE VPT blocks -----------------------===//
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 #include "ARM.h"
10 #include "ARMMachineFunctionInfo.h"
11 #include "ARMSubtarget.h"
12 #include "MCTargetDesc/ARMBaseInfo.h"
13 #include "Thumb2InstrInfo.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/Statistic.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/CodeGen/MachineBasicBlock.h"
18 #include "llvm/CodeGen/MachineFunction.h"
19 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/CodeGen/MachineInstr.h"
21 #include "llvm/CodeGen/MachineInstrBuilder.h"
22 #include "llvm/CodeGen/MachineInstrBundle.h"
23 #include "llvm/CodeGen/MachineOperand.h"
24 #include "llvm/IR/DebugLoc.h"
25 #include "llvm/MC/MCInstrDesc.h"
26 #include "llvm/MC/MCRegisterInfo.h"
27 #include "llvm/Support/Debug.h"
28 #include <cassert>
29 #include <new>
30 
31 using namespace llvm;
32 
33 #define DEBUG_TYPE "arm-mve-vpt"
34 
35 namespace {
36 class MVEVPTBlock : public MachineFunctionPass {
37 public:
38   static char ID;
39   const Thumb2InstrInfo *TII;
40   const TargetRegisterInfo *TRI;
41 
42   MVEVPTBlock() : MachineFunctionPass(ID) {}
43 
44   bool runOnMachineFunction(MachineFunction &Fn) override;
45 
46   MachineFunctionProperties getRequiredProperties() const override {
47     return MachineFunctionProperties().set(
48         MachineFunctionProperties::Property::NoVRegs);
49   }
50 
51   StringRef getPassName() const override {
52     return "MVE VPT block insertion pass";
53   }
54 
55 private:
56   bool InsertVPTBlocks(MachineBasicBlock &MBB);
57 };
58 
59 char MVEVPTBlock::ID = 0;
60 
61 } // end anonymous namespace
62 
63 INITIALIZE_PASS(MVEVPTBlock, DEBUG_TYPE, "ARM MVE VPT block pass", false, false)
64 
65 static MachineInstr *findVCMPToFoldIntoVPST(MachineBasicBlock::iterator MI,
66                                             const TargetRegisterInfo *TRI,
67                                             unsigned &NewOpcode) {
68   // Search backwards to the instruction that defines VPR. This may or not
69   // be a VCMP, we check that after this loop. If we find another instruction
70   // that reads cpsr, we return nullptr.
71   MachineBasicBlock::iterator CmpMI = MI;
72   while (CmpMI != MI->getParent()->begin()) {
73     --CmpMI;
74     if (CmpMI->modifiesRegister(ARM::VPR, TRI))
75       break;
76     if (CmpMI->readsRegister(ARM::VPR, TRI))
77       break;
78   }
79 
80   if (CmpMI == MI)
81     return nullptr;
82   NewOpcode = VCMPOpcodeToVPT(CmpMI->getOpcode());
83   if (NewOpcode == 0)
84     return nullptr;
85 
86   // Search forward from CmpMI to MI, checking if either register was def'd
87   if (registerDefinedBetween(CmpMI->getOperand(1).getReg(), std::next(CmpMI),
88                              MI, TRI))
89     return nullptr;
90   if (registerDefinedBetween(CmpMI->getOperand(2).getReg(), std::next(CmpMI),
91                              MI, TRI))
92     return nullptr;
93   return &*CmpMI;
94 }
95 
96 // Advances Iter past a block of predicated instructions.
97 // Returns true if it successfully skipped the whole block of predicated
98 // instructions. Returns false when it stopped early (due to MaxSteps), or if
99 // Iter didn't point to a predicated instruction.
100 static bool StepOverPredicatedInstrs(MachineBasicBlock::instr_iterator &Iter,
101                                      MachineBasicBlock::instr_iterator EndIter,
102                                      unsigned MaxSteps,
103                                      unsigned &NumInstrsSteppedOver) {
104   ARMVCC::VPTCodes NextPred = ARMVCC::None;
105   Register PredReg;
106   NumInstrsSteppedOver = 0;
107 
108   while (Iter != EndIter) {
109     if (Iter->isDebugInstr()) {
110       // Skip debug instructions
111       ++Iter;
112       continue;
113     }
114 
115     NextPred = getVPTInstrPredicate(*Iter, PredReg);
116     assert(NextPred != ARMVCC::Else &&
117            "VPT block pass does not expect Else preds");
118     if (NextPred == ARMVCC::None || MaxSteps == 0)
119       break;
120     --MaxSteps;
121     ++Iter;
122     ++NumInstrsSteppedOver;
123   };
124 
125   return NumInstrsSteppedOver != 0 &&
126          (NextPred == ARMVCC::None || Iter == EndIter);
127 }
128 
129 // Returns true if at least one instruction in the range [Iter, End) defines
130 // or kills VPR.
131 static bool IsVPRDefinedOrKilledByBlock(MachineBasicBlock::iterator Iter,
132                                         MachineBasicBlock::iterator End) {
133   for (; Iter != End; ++Iter)
134     if (Iter->definesRegister(ARM::VPR) || Iter->killsRegister(ARM::VPR))
135       return true;
136   return false;
137 }
138 
139 // Creates a T, TT, TTT or TTTT BlockMask depending on BlockSize.
140 static ARM::PredBlockMask GetInitialBlockMask(unsigned BlockSize) {
141   switch (BlockSize) {
142   case 1:
143     return ARM::PredBlockMask::T;
144   case 2:
145     return ARM::PredBlockMask::TT;
146   case 3:
147     return ARM::PredBlockMask::TTT;
148   case 4:
149     return ARM::PredBlockMask::TTTT;
150   default:
151     llvm_unreachable("Invalid BlockSize!");
152   }
153 }
154 
155 // Given an iterator (Iter) that points at an instruction with a "Then"
156 // predicate, tries to create the largest block of continuous predicated
157 // instructions possible, and returns the VPT Block Mask of that block.
158 //
159 // This will try to perform some minor optimization in order to maximize the
160 // size of the block.
161 static ARM::PredBlockMask
162 CreateVPTBlock(MachineBasicBlock::instr_iterator &Iter,
163                MachineBasicBlock::instr_iterator EndIter,
164                SmallVectorImpl<MachineInstr *> &DeadInstructions) {
165   MachineBasicBlock::instr_iterator BlockBeg = Iter;
166   (void)BlockBeg;
167   assert(getVPTInstrPredicate(*Iter) == ARMVCC::Then &&
168          "Expected a Predicated Instruction");
169 
170   LLVM_DEBUG(dbgs() << "VPT block created for: "; Iter->dump());
171 
172   unsigned BlockSize;
173   StepOverPredicatedInstrs(Iter, EndIter, 4, BlockSize);
174 
175   LLVM_DEBUG(for (MachineBasicBlock::instr_iterator AddedInstIter =
176                       std::next(BlockBeg);
177                   AddedInstIter != Iter; ++AddedInstIter) {
178     if (AddedInstIter->isDebugInstr())
179       continue;
180     dbgs() << "  adding: ";
181     AddedInstIter->dump();
182   });
183 
184   // Generate the initial BlockMask
185   ARM::PredBlockMask BlockMask = GetInitialBlockMask(BlockSize);
186 
187   // Remove VPNOTs while there's still room in the block, so we can make the
188   // largest block possible.
189   ARMVCC::VPTCodes CurrentPredicate = ARMVCC::Else;
190   while (BlockSize < 4 && Iter != EndIter &&
191          Iter->getOpcode() == ARM::MVE_VPNOT) {
192 
193     // Try to skip all of the predicated instructions after the VPNOT, stopping
194     // after (4 - BlockSize). If we can't skip them all, stop.
195     unsigned ElseInstCnt = 0;
196     MachineBasicBlock::instr_iterator VPNOTBlockEndIter = std::next(Iter);
197     if (!StepOverPredicatedInstrs(VPNOTBlockEndIter, EndIter, (4 - BlockSize),
198                                   ElseInstCnt))
199       break;
200 
201     // Check if this VPNOT can be removed or not: It can only be removed if at
202     // least one of the predicated instruction that follows it kills or sets
203     // VPR.
204     if (!IsVPRDefinedOrKilledByBlock(Iter, VPNOTBlockEndIter))
205       break;
206 
207     LLVM_DEBUG(dbgs() << "  removing VPNOT: "; Iter->dump());
208 
209     // Record the new size of the block
210     BlockSize += ElseInstCnt;
211     assert(BlockSize <= 4 && "Block is too large!");
212 
213     // Record the VPNot to remove it later.
214     DeadInstructions.push_back(&*Iter);
215     ++Iter;
216 
217     // Replace the predicates of the instructions we're adding.
218     // Note that we are using "Iter" to iterate over the block so we can update
219     // it at the same time.
220     for (; Iter != VPNOTBlockEndIter; ++Iter) {
221       if (Iter->isDebugInstr())
222         continue;
223 
224       // Find the register in which the predicate is
225       int OpIdx = findFirstVPTPredOperandIdx(*Iter);
226       assert(OpIdx != -1);
227 
228       // Change the predicate and update the mask
229       Iter->getOperand(OpIdx).setImm(CurrentPredicate);
230       BlockMask = expandPredBlockMask(BlockMask, CurrentPredicate);
231 
232       LLVM_DEBUG(dbgs() << "  adding : "; Iter->dump());
233     }
234 
235     CurrentPredicate =
236         (CurrentPredicate == ARMVCC::Then ? ARMVCC::Else : ARMVCC::Then);
237   }
238   return BlockMask;
239 }
240 
241 bool MVEVPTBlock::InsertVPTBlocks(MachineBasicBlock &Block) {
242   bool Modified = false;
243   MachineBasicBlock::instr_iterator MBIter = Block.instr_begin();
244   MachineBasicBlock::instr_iterator EndIter = Block.instr_end();
245 
246   SmallVector<MachineInstr *, 4> DeadInstructions;
247 
248   while (MBIter != EndIter) {
249     MachineInstr *MI = &*MBIter;
250     Register PredReg;
251     DebugLoc DL = MI->getDebugLoc();
252 
253     ARMVCC::VPTCodes Pred = getVPTInstrPredicate(*MI, PredReg);
254 
255     // The idea of the predicate is that None, Then and Else are for use when
256     // handling assembly language: they correspond to the three possible
257     // suffixes "", "t" and "e" on the mnemonic. So when instructions are read
258     // from assembly source or disassembled from object code, you expect to
259     // see a mixture whenever there's a long VPT block. But in code
260     // generation, we hope we'll never generate an Else as input to this pass.
261     assert(Pred != ARMVCC::Else && "VPT block pass does not expect Else preds");
262 
263     if (Pred == ARMVCC::None) {
264       ++MBIter;
265       continue;
266     }
267 
268     ARM::PredBlockMask BlockMask =
269         CreateVPTBlock(MBIter, EndIter, DeadInstructions);
270 
271     // Search back for a VCMP that can be folded to create a VPT, or else
272     // create a VPST directly
273     MachineInstrBuilder MIBuilder;
274     unsigned NewOpcode;
275     LLVM_DEBUG(dbgs() << "  final block mask: " << (unsigned)BlockMask << "\n");
276     if (MachineInstr *VCMP = findVCMPToFoldIntoVPST(MI, TRI, NewOpcode)) {
277       LLVM_DEBUG(dbgs() << "  folding VCMP into VPST: "; VCMP->dump());
278       MIBuilder = BuildMI(Block, MI, DL, TII->get(NewOpcode));
279       MIBuilder.addImm((uint64_t)BlockMask);
280       MIBuilder.add(VCMP->getOperand(1));
281       MIBuilder.add(VCMP->getOperand(2));
282       MIBuilder.add(VCMP->getOperand(3));
283 
284       // We need to remove any kill flags between the original VCMP and the new
285       // insertion point.
286       for (MachineInstr &MII :
287            make_range(VCMP->getIterator(), MI->getIterator())) {
288         MII.clearRegisterKills(VCMP->getOperand(1).getReg(), TRI);
289         MII.clearRegisterKills(VCMP->getOperand(2).getReg(), TRI);
290       }
291 
292       VCMP->eraseFromParent();
293     } else {
294       MIBuilder = BuildMI(Block, MI, DL, TII->get(ARM::MVE_VPST));
295       MIBuilder.addImm((uint64_t)BlockMask);
296     }
297 
298     // Erase all dead instructions (VPNOT's). Do that now so that they do not
299     // mess with the bundle creation.
300     for (MachineInstr *DeadMI : DeadInstructions)
301       DeadMI->eraseFromParent();
302     DeadInstructions.clear();
303 
304     finalizeBundle(
305         Block, MachineBasicBlock::instr_iterator(MIBuilder.getInstr()), MBIter);
306 
307     Modified = true;
308   }
309 
310   return Modified;
311 }
312 
313 bool MVEVPTBlock::runOnMachineFunction(MachineFunction &Fn) {
314   const ARMSubtarget &STI = Fn.getSubtarget<ARMSubtarget>();
315 
316   if (!STI.isThumb2() || !STI.hasMVEIntegerOps())
317     return false;
318 
319   TII = static_cast<const Thumb2InstrInfo *>(STI.getInstrInfo());
320   TRI = STI.getRegisterInfo();
321 
322   LLVM_DEBUG(dbgs() << "********** ARM MVE VPT BLOCKS **********\n"
323                     << "********** Function: " << Fn.getName() << '\n');
324 
325   bool Modified = false;
326   for (MachineBasicBlock &MBB : Fn)
327     Modified |= InsertVPTBlocks(MBB);
328 
329   LLVM_DEBUG(dbgs() << "**************************************\n");
330   return Modified;
331 }
332 
333 /// createMVEVPTBlock - Returns an instance of the MVE VPT block
334 /// insertion pass.
335 FunctionPass *llvm::createMVEVPTBlockPass() { return new MVEVPTBlock(); }
336