contrib/llvm/lib/Target/Mips/MipsHazardSchedule.cpp

   1 //===- MipsHazardSchedule.cpp - Workaround pipeline hazards ---------------===//
   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 pass is used to workaround certain pipeline hazards. For now, this
  11 /// covers compact branch hazards. In future this pass can be extended to other
  12 /// pipeline hazards, such as various MIPS1 hazards, processor errata that
  13 /// require instruction reorganization, etc.
  14 ///
  15 /// This pass has to run after the delay slot filler as that pass can introduce
  16 /// pipeline hazards, hence the existing hazard recognizer is not suitable.
  17 ///
  18 /// Hazards handled: forbidden slots for MIPSR6.
  19 ///
  20 /// A forbidden slot hazard occurs when a compact branch instruction is executed
  21 /// and the adjacent instruction in memory is a control transfer instruction
  22 /// such as a branch or jump, ERET, ERETNC, DERET, WAIT and PAUSE.
  23 ///
  24 /// For example:
  25 ///
  26 /// 0x8004      bnec    a1,v0,<P+0x18>
  27 /// 0x8008      beqc    a1,a2,<P+0x54>
  28 ///
  29 /// In such cases, the processor is required to signal a Reserved Instruction
  30 /// exception.
  31 ///
  32 /// Here, if the instruction at 0x8004 is executed, the processor will raise an
  33 /// exception as there is a control transfer instruction at 0x8008.
  34 ///
  35 /// There are two sources of forbidden slot hazards:
  36 ///
  37 /// A) A previous pass has created a compact branch directly.
  38 /// B) Transforming a delay slot branch into compact branch. This case can be
  39 ///    difficult to process as lookahead for hazards is insufficient, as
  40 ///    backwards delay slot fillling can also produce hazards in previously
  41 ///    processed instuctions.
  42 ///
  43 //===----------------------------------------------------------------------===//
  44
  45 #include "Mips.h"
  46 #include "MipsInstrInfo.h"
  47 #include "MipsSubtarget.h"
  48 #include "llvm/ADT/Statistic.h"
  49 #include "llvm/CodeGen/MachineBasicBlock.h"
  50 #include "llvm/CodeGen/MachineFunction.h"
  51 #include "llvm/CodeGen/MachineFunctionPass.h"
  52 #include "llvm/CodeGen/MachineInstrBuilder.h"
  53 #include <algorithm>
  54 #include <iterator>
  55 #include <utility>
  56
  57 using namespace llvm;
  58
  59 #define DEBUG_TYPE "mips-hazard-schedule"
  60
  61 STATISTIC(NumInsertedNops, "Number of nops inserted");
  62
  63 namespace {
  64
  65 using Iter = MachineBasicBlock::iterator;
  66 using ReverseIter = MachineBasicBlock::reverse_iterator;
  67
  68 class MipsHazardSchedule : public MachineFunctionPass {
  69 public:
  70   MipsHazardSchedule() : MachineFunctionPass(ID) {}
  71
  72   StringRef getPassName() const override { return "Mips Hazard Schedule"; }
  73
  74   bool runOnMachineFunction(MachineFunction &F) override;
  75
  76   MachineFunctionProperties getRequiredProperties() const override {
  77     return MachineFunctionProperties().set(
  78         MachineFunctionProperties::Property::NoVRegs);
  79   }
  80
  81 private:
  82   static char ID;
  83 };
  84
  85 } // end of anonymous namespace
  86
  87 char MipsHazardSchedule::ID = 0;
  88
  89 /// Returns a pass that clears pipeline hazards.
  90 FunctionPass *llvm::createMipsHazardSchedule() {
  91   return new MipsHazardSchedule();
  92 }
  93
  94 // Find the next real instruction from the current position in current basic
  95 // block.
  96 static Iter getNextMachineInstrInBB(Iter Position) {
  97   Iter I = Position, E = Position->getParent()->end();
  98   I = std::find_if_not(I, E,
  99                        [](const Iter &Insn) { return Insn->isTransient(); });
 100
 101   return I;
 102 }
 103
 104 // Find the next real instruction from the current position, looking through
 105 // basic block boundaries.
 106 static std::pair<Iter, bool> getNextMachineInstr(Iter Position, MachineBasicBlock * Parent) {
 107   if (Position == Parent->end()) {
 108     do {
 109       MachineBasicBlock *Succ = Parent->getNextNode();
 110       if (Succ != nullptr && Parent->isSuccessor(Succ)) {
 111         Position = Succ->begin();
 112         Parent = Succ;
 113       } else {
 114         return std::make_pair(Position, true);
 115       }
 116     } while (Parent->empty());
 117   }
 118
 119   Iter Instr = getNextMachineInstrInBB(Position);
 120   if (Instr == Parent->end()) {
 121     return getNextMachineInstr(Instr, Parent);
 122   }
 123   return std::make_pair(Instr, false);
 124 }
 125
 126 bool MipsHazardSchedule::runOnMachineFunction(MachineFunction &MF) {
 127
 128   const MipsSubtarget *STI =
 129       &static_cast<const MipsSubtarget &>(MF.getSubtarget());
 130
 131   // Forbidden slot hazards are only defined for MIPSR6 but not microMIPSR6.
 132   if (!STI->hasMips32r6() || STI->inMicroMipsMode())
 133     return false;
 134
 135   bool Changed = false;
 136   const MipsInstrInfo *TII = STI->getInstrInfo();
 137
 138   for (MachineFunction::iterator FI = MF.begin(); FI != MF.end(); ++FI) {
 139     for (Iter I = FI->begin(); I != FI->end(); ++I) {
 140
 141       // Forbidden slot hazard handling. Use lookahead over state.
 142       if (!TII->HasForbiddenSlot(*I))
 143         continue;
 144
 145       Iter Inst;
 146       bool LastInstInFunction =
 147           std::next(I) == FI->end() && std::next(FI) == MF.end();
 148       if (!LastInstInFunction) {
 149         std::pair<Iter, bool> Res = getNextMachineInstr(std::next(I), &*FI);
 150         LastInstInFunction |= Res.second;
 151         Inst = Res.first;
 152       }
 153
 154       if (LastInstInFunction || !TII->SafeInForbiddenSlot(*Inst)) {
 155         Changed = true;
 156         MIBundleBuilder(&*I)
 157             .append(BuildMI(MF, I->getDebugLoc(), TII->get(Mips::NOP)));
 158         NumInsertedNops++;
 159       }
 160     }
 161   }
 162   return Changed;
 163 }