Line data    Source code

       1             : ///===- MachineOptimizationRemarkEmitter.cpp - Opt Diagnostic -*- C++ -*---===//
       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             : /// Optimization diagnostic interfaces for machine passes.  It's packaged as an
      11             : /// analysis pass so that by using this service passes become dependent on MBFI
      12             : /// as well.  MBFI is used to compute the "hotness" of the diagnostic message.
      13             : ///
      14             : ///===---------------------------------------------------------------------===//
      15             : 
      16             : #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
      17             : #include "llvm/CodeGen/LazyMachineBlockFrequencyInfo.h"
      18             : #include "llvm/CodeGen/MachineInstr.h"
      19             : #include "llvm/IR/DiagnosticInfo.h"
      20             : #include "llvm/IR/LLVMContext.h"
      21             : 
      22             : using namespace llvm;
      23             : 
      24          24 : DiagnosticInfoMIROptimization::MachineArgument::MachineArgument(
      25          24 :     StringRef MKey, const MachineInstr &MI)
      26          48 :     : Argument() {
      27          24 :   Key = MKey;
      28             : 
      29          24 :   raw_string_ostream OS(Val);
      30          24 :   MI.print(OS, /*IsStandalone=*/true, /*SkipOpers=*/false,
      31             :            /*SkipDebugLoc=*/true);
      32          24 : }
      33             : 
      34             : Optional<uint64_t>
      35      406377 : MachineOptimizationRemarkEmitter::computeHotness(const MachineBasicBlock &MBB) {
      36      406377 :   if (!MBFI)
      37             :     return None;
      38             : 
      39          62 :   return MBFI->getBlockProfileCount(&MBB);
      40             : }
      41             : 
      42      406377 : void MachineOptimizationRemarkEmitter::computeHotness(
      43             :     DiagnosticInfoMIROptimization &Remark) {
      44      406377 :   const MachineBasicBlock *MBB = Remark.getBlock();
      45      406377 :   if (MBB)
      46      812754 :     Remark.setHotness(computeHotness(*MBB));
      47      406377 : }
      48             : 
      49      406377 : void MachineOptimizationRemarkEmitter::emit(
      50             :     DiagnosticInfoOptimizationBase &OptDiagCommon) {
      51             :   auto &OptDiag = cast<DiagnosticInfoMIROptimization>(OptDiagCommon);
      52      406377 :   computeHotness(OptDiag);
      53             : 
      54      406377 :   LLVMContext &Ctx = MF.getFunction().getContext();
      55             : 
      56             :   // Only emit it if its hotness meets the threshold.
      57      406377 :   if (OptDiag.getHotness().getValueOr(0) <
      58      406377 :       Ctx.getDiagnosticsHotnessThreshold()) {
      59             :     return;
      60             :   }
      61             : 
      62      406364 :   Ctx.diagnose(OptDiag);
      63             : }
      64             : 
      65       73779 : MachineOptimizationRemarkEmitterPass::MachineOptimizationRemarkEmitterPass()
      66       73779 :     : MachineFunctionPass(ID) {
      67       73779 :   initializeMachineOptimizationRemarkEmitterPassPass(
      68       73779 :       *PassRegistry::getPassRegistry());
      69       73779 : }
      70             : 
      71     1004159 : bool MachineOptimizationRemarkEmitterPass::runOnMachineFunction(
      72             :     MachineFunction &MF) {
      73             :   MachineBlockFrequencyInfo *MBFI;
      74             : 
      75     1004159 :   if (MF.getFunction().getContext().getDiagnosticsHotnessRequested())
      76          66 :     MBFI = &getAnalysis<LazyMachineBlockFrequencyInfoPass>().getBFI();
      77             :   else
      78             :     MBFI = nullptr;
      79             : 
      80             :   ORE = llvm::make_unique<MachineOptimizationRemarkEmitter>(MF, MBFI);
      81     1004159 :   return false;
      82             : }
      83             : 
      84       73779 : void MachineOptimizationRemarkEmitterPass::getAnalysisUsage(
      85             :     AnalysisUsage &AU) const {
      86             :   AU.addRequired<LazyMachineBlockFrequencyInfoPass>();
      87             :   AU.setPreservesAll();
      88       73779 :   MachineFunctionPass::getAnalysisUsage(AU);
      89       73779 : }
      90             : 
      91             : char MachineOptimizationRemarkEmitterPass::ID = 0;
      92             : static const char ore_name[] = "Machine Optimization Remark Emitter";
      93             : #define ORE_NAME "machine-opt-remark-emitter"
      94             : 
      95       31780 : INITIALIZE_PASS_BEGIN(MachineOptimizationRemarkEmitterPass, ORE_NAME, ore_name,
      96             :                       false, true)
      97       31780 : INITIALIZE_PASS_DEPENDENCY(LazyMachineBlockFrequencyInfoPass)
      98      254266 : INITIALIZE_PASS_END(MachineOptimizationRemarkEmitterPass, ORE_NAME, ore_name,
      99             :                     false, true)