LCOV - code coverage report
Current view: top level - lib/CodeGen - PostRAHazardRecognizer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 21 21 100.0 %
Date: 2017-09-14 15:23:50 Functions: 5 6 83.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===----- PostRAHazardRecognizer.cpp - hazard recognizer -----------------===//
       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             : //
      10             : /// \file
      11             : /// This runs the hazard recognizer and emits noops when necessary.  This
      12             : /// gives targets a way to run the hazard recognizer without running one of
      13             : /// the schedulers.  Example use cases for this pass would be:
      14             : ///
      15             : /// - Targets that need the hazard recognizer to be run at -O0.
      16             : /// - Targets that want to guarantee that hazards at the beginning of
      17             : ///   scheduling regions are handled correctly.  The post-RA scheduler is
      18             : ///   a top-down scheduler, but when there are multiple scheduling regions
      19             : ///   in a basic block, it visits the regions in bottom-up order.  This
      20             : ///   makes it impossible for the scheduler to gauranttee it can correctly
      21             : ///   handle hazards at the beginning of scheduling regions.
      22             : ///
      23             : /// This pass traverses all the instructions in a program in top-down order.
      24             : /// In contrast to the instruction scheduling passes, this pass never resets
      25             : /// the hazard recognizer to ensure it can correctly handles noop hazards at
      26             : /// the beginning of blocks.
      27             : //
      28             : //===----------------------------------------------------------------------===//
      29             : 
      30             : #include "llvm/ADT/Statistic.h"
      31             : #include "llvm/CodeGen/MachineFunctionPass.h"
      32             : #include "llvm/CodeGen/Passes.h"
      33             : #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
      34             : #include "llvm/Support/Debug.h"
      35             : #include "llvm/Support/ErrorHandling.h"
      36             : #include "llvm/Support/raw_ostream.h"
      37             : #include "llvm/Target/TargetInstrInfo.h"
      38             : #include "llvm/Target/TargetSubtargetInfo.h"
      39             : using namespace llvm;
      40             : 
      41             : #define DEBUG_TYPE "post-RA-hazard-rec"
      42             : 
      43             : STATISTIC(NumNoops, "Number of noops inserted");
      44             : 
      45             : namespace {
      46        1466 :   class PostRAHazardRecognizer : public MachineFunctionPass {
      47             : 
      48             :   public:
      49             :     static char ID;
      50        1474 :     PostRAHazardRecognizer() : MachineFunctionPass(ID) {}
      51             : 
      52        1467 :     void getAnalysisUsage(AnalysisUsage &AU) const override {
      53        1467 :       AU.setPreservesCFG();
      54        1467 :       MachineFunctionPass::getAnalysisUsage(AU);
      55        1467 :     }
      56             : 
      57             :     bool runOnMachineFunction(MachineFunction &Fn) override;
      58             : 
      59             :   };
      60             :   char PostRAHazardRecognizer::ID = 0;
      61             : 
      62             : }
      63             : 
      64             : char &llvm::PostRAHazardRecognizerID = PostRAHazardRecognizer::ID;
      65             : 
      66      151199 : INITIALIZE_PASS(PostRAHazardRecognizer, DEBUG_TYPE,
      67             :                 "Post RA hazard recognizer", false, false)
      68             : 
      69       14880 : bool PostRAHazardRecognizer::runOnMachineFunction(MachineFunction &Fn) {
      70       14880 :   const TargetInstrInfo *TII = Fn.getSubtarget().getInstrInfo();
      71             :   std::unique_ptr<ScheduleHazardRecognizer> HazardRec(
      72       44640 :       TII->CreateTargetPostRAHazardRecognizer(Fn));
      73             : 
      74             :   // Return if the target has not implemented a hazard recognizer.
      75       14880 :   if (!HazardRec.get())
      76             :     return false;
      77             : 
      78             :   // Loop over all of the basic blocks
      79       61494 :   for (auto &MBB : Fn) {
      80             :     // We do not call HazardRec->reset() here to make sure we are handling noop
      81             :     // hazards at the start of basic blocks.
      82      601464 :     for (MachineInstr &MI : MBB) {
      83             :       // If we need to emit noops prior to this instruction, then do so.
      84      267024 :       unsigned NumPreNoops = HazardRec->PreEmitNoops(&MI);
      85      267298 :       for (unsigned i = 0; i != NumPreNoops; ++i) {
      86         274 :         HazardRec->EmitNoop();
      87         548 :         TII->insertNoop(MBB, MachineBasicBlock::iterator(MI));
      88         274 :         ++NumNoops;
      89             :       }
      90             : 
      91      267024 :       HazardRec->EmitInstruction(&MI);
      92      267024 :       if (HazardRec->atIssueLimit()) {
      93      267024 :         HazardRec->AdvanceCycle();
      94             :       }
      95             :     }
      96             :   }
      97             :   return true;
      98             : }

Generated by: LCOV version 1.13