LCOV - code coverage report
Current view: top level - lib/Analysis - OptimizationRemarkEmitter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 41 41 100.0 %
Date: 2018-02-18 03:11:45 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- OptimizationRemarkEmitter.cpp - Optimization 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             : //
      10             : // Optimization diagnostic interfaces.  It's packaged as an analysis pass so
      11             : // that by using this service passes become dependent on BFI as well.  BFI is
      12             : // used to compute the "hotness" of the diagnostic message.
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "llvm/Analysis/OptimizationRemarkEmitter.h"
      16             : #include "llvm/Analysis/BranchProbabilityInfo.h"
      17             : #include "llvm/Analysis/LazyBlockFrequencyInfo.h"
      18             : #include "llvm/Analysis/LoopInfo.h"
      19             : #include "llvm/IR/DiagnosticInfo.h"
      20             : #include "llvm/IR/Dominators.h"
      21             : #include "llvm/IR/LLVMContext.h"
      22             : 
      23             : using namespace llvm;
      24             : 
      25     1366461 : OptimizationRemarkEmitter::OptimizationRemarkEmitter(const Function *F)
      26     1366461 :     : F(F), BFI(nullptr) {
      27     1366461 :   if (!F->getContext().getDiagnosticsHotnessRequested())
      28     1366325 :     return;
      29             : 
      30             :   // First create a dominator tree.
      31             :   DominatorTree DT;
      32             :   DT.recalculate(*const_cast<Function *>(F));
      33             : 
      34             :   // Generate LoopInfo from it.
      35             :   LoopInfo LI;
      36         136 :   LI.analyze(DT);
      37             : 
      38             :   // Then compute BranchProbabilityInfo.
      39         272 :   BranchProbabilityInfo BPI;
      40         136 :   BPI.calculate(*F, LI);
      41             : 
      42             :   // Finally compute BFI.
      43         136 :   OwnedBFI = llvm::make_unique<BlockFrequencyInfo>(*F, BPI, LI);
      44         136 :   BFI = OwnedBFI.get();
      45             : }
      46             : 
      47        1223 : bool OptimizationRemarkEmitter::invalidate(
      48             :     Function &F, const PreservedAnalyses &PA,
      49             :     FunctionAnalysisManager::Invalidator &Inv) {
      50             :   // This analysis has no state and so can be trivially preserved but it needs
      51             :   // a fresh view of BFI if it was constructed with one.
      52        1242 :   if (BFI && Inv.invalidate<BlockFrequencyAnalysis>(F, PA))
      53             :     return true;
      54             : 
      55             :   // Otherwise this analysis result remains valid.
      56             :   return false;
      57             : }
      58             : 
      59      115443 : Optional<uint64_t> OptimizationRemarkEmitter::computeHotness(const Value *V) {
      60      115443 :   if (!BFI)
      61             :     return None;
      62             : 
      63         107 :   return BFI->getBlockProfileCount(cast<BasicBlock>(V));
      64             : }
      65             : 
      66      115443 : void OptimizationRemarkEmitter::computeHotness(
      67             :     DiagnosticInfoIROptimization &OptDiag) {
      68             :   const Value *V = OptDiag.getCodeRegion();
      69      115443 :   if (V)
      70      230886 :     OptDiag.setHotness(computeHotness(V));
      71      115443 : }
      72             : 
      73      115443 : void OptimizationRemarkEmitter::emit(
      74             :     DiagnosticInfoOptimizationBase &OptDiagBase) {
      75             :   auto &OptDiag = cast<DiagnosticInfoIROptimization>(OptDiagBase);
      76      115443 :   computeHotness(OptDiag);
      77             : 
      78             :   // Only emit it if its hotness meets the threshold.
      79      115443 :   if (OptDiag.getHotness().getValueOr(0) <
      80      115443 :       F->getContext().getDiagnosticsHotnessThreshold()) {
      81             :     return;
      82             :   }
      83             : 
      84      115431 :   F->getContext().diagnose(OptDiag);
      85             : }
      86             : 
      87       22673 : OptimizationRemarkEmitterWrapperPass::OptimizationRemarkEmitterWrapperPass()
      88       22673 :     : FunctionPass(ID) {
      89       22673 :   initializeOptimizationRemarkEmitterWrapperPassPass(
      90       22673 :       *PassRegistry::getPassRegistry());
      91       22673 : }
      92             : 
      93      371089 : bool OptimizationRemarkEmitterWrapperPass::runOnFunction(Function &Fn) {
      94             :   BlockFrequencyInfo *BFI;
      95             : 
      96      371089 :   if (Fn.getContext().getDiagnosticsHotnessRequested())
      97         140 :     BFI = &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI();
      98             :   else
      99             :     BFI = nullptr;
     100             : 
     101      371089 :   ORE = llvm::make_unique<OptimizationRemarkEmitter>(&Fn, BFI);
     102      371089 :   return false;
     103             : }
     104             : 
     105       22676 : void OptimizationRemarkEmitterWrapperPass::getAnalysisUsage(
     106             :     AnalysisUsage &AU) const {
     107       22676 :   LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU);
     108             :   AU.setPreservesAll();
     109       22676 : }
     110             : 
     111             : AnalysisKey OptimizationRemarkEmitterAnalysis::Key;
     112             : 
     113             : OptimizationRemarkEmitter
     114        1093 : OptimizationRemarkEmitterAnalysis::run(Function &F,
     115             :                                        FunctionAnalysisManager &AM) {
     116             :   BlockFrequencyInfo *BFI;
     117             : 
     118        1093 :   if (F.getContext().getDiagnosticsHotnessRequested())
     119             :     BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
     120             :   else
     121             :     BFI = nullptr;
     122             : 
     123             :   return OptimizationRemarkEmitter(&F, BFI);
     124             : }
     125             : 
     126             : char OptimizationRemarkEmitterWrapperPass::ID = 0;
     127             : static const char ore_name[] = "Optimization Remark Emitter";
     128             : #define ORE_NAME "opt-remark-emitter"
     129             : 
     130       55277 : INITIALIZE_PASS_BEGIN(OptimizationRemarkEmitterWrapperPass, ORE_NAME, ore_name,
     131             :                       false, true)
     132       55277 : INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)
     133      818928 : INITIALIZE_PASS_END(OptimizationRemarkEmitterWrapperPass, ORE_NAME, ore_name,
     134             :                     false, true)

Generated by: LCOV version 1.13