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