llvm/lib/Analysis/OptimizationRemarkEmitter.cpp

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