1 //===- OptimizationRemarkEmitter.h - 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 #ifndef LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
16 #define LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
17 
18 #include "llvm/ADT/Optional.h"
19 #include "llvm/Analysis/BlockFrequencyInfo.h"
20 #include "llvm/IR/DiagnosticInfo.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/PassManager.h"
23 #include "llvm/Pass.h"
24 
25 namespace llvm {
26 class DebugLoc;
27 class Loop;
28 class Pass;
29 class Twine;
30 class Value;
31 
32 /// The optimization diagnostic interface.
33 ///
34 /// It allows reporting when optimizations are performed and when they are not
35 /// along with the reasons for it.  Hotness information of the corresponding
36 /// code region can be included in the remark if DiagnosticsHotnessRequested is
37 /// enabled in the LLVM context.
38 class OptimizationRemarkEmitter {
39 public:
OptimizationRemarkEmitter(const Function * F,BlockFrequencyInfo * BFI)40   OptimizationRemarkEmitter(const Function *F, BlockFrequencyInfo *BFI)
41       : F(F), BFI(BFI) {}
42 
43   /// This variant can be used to generate ORE on demand (without the
44   /// analysis pass).
45   ///
46   /// Note that this ctor has a very different cost depending on whether
47   /// F->getContext().getDiagnosticsHotnessRequested() is on or not.  If it's off
48   /// the operation is free.
49   ///
50   /// Whereas if DiagnosticsHotnessRequested is on, it is fairly expensive
51   /// operation since BFI and all its required analyses are computed.  This is
52   /// for example useful for CGSCC passes that can't use function analyses
53   /// passes in the old PM.
54   OptimizationRemarkEmitter(const Function *F);
55 
OptimizationRemarkEmitter(OptimizationRemarkEmitter && Arg)56   OptimizationRemarkEmitter(OptimizationRemarkEmitter &&Arg)
57       : F(Arg.F), BFI(Arg.BFI) {}
58 
59   OptimizationRemarkEmitter &operator=(OptimizationRemarkEmitter &&RHS) {
60     F = RHS.F;
61     BFI = RHS.BFI;
62     return *this;
63   }
64 
65   /// Handle invalidation events in the new pass manager.
66   bool invalidate(Function &F, const PreservedAnalyses &PA,
67                   FunctionAnalysisManager::Invalidator &Inv);
68 
69   /// Output the remark via the diagnostic handler and to the
70   /// optimization record file.
71   void emit(DiagnosticInfoOptimizationBase &OptDiag);
72 
73   /// Take a lambda that returns a remark which will be emitted.  Second
74   /// argument is only used to restrict this to functions.
75   template <typename T>
76   void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77     // Avoid building the remark unless we know there are at least *some*
78     // remarks enabled. We can't currently check whether remarks are requested
79     // for the calling pass since that requires actually building the remark.
80 
81     if (F->getContext().getDiagnosticsOutputFile() ||
82         F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83       auto R = RemarkBuilder();
84       emit((DiagnosticInfoOptimizationBase &)R);
85     }
86   }
87 
88   /// Whether we allow for extra compile-time budget to perform more
89   /// analysis to produce fewer false positives.
90   ///
91   /// This is useful when reporting missed optimizations.  In this case we can
92   /// use the extra analysis (1) to filter trivial false positives or (2) to
93   /// provide more context so that non-trivial false positives can be quickly
94   /// detected by the user.
allowExtraAnalysis(StringRef PassName)95   bool allowExtraAnalysis(StringRef PassName) const {
96     return (F->getContext().getDiagnosticsOutputFile() ||
97             F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName));
98   }
99 
100 private:
101   const Function *F;
102 
103   BlockFrequencyInfo *BFI;
104 
105   /// If we generate BFI on demand, we need to free it when ORE is freed.
106   std::unique_ptr<BlockFrequencyInfo> OwnedBFI;
107 
108   /// Compute hotness from IR value (currently assumed to be a block) if PGO is
109   /// available.
110   Optional<uint64_t> computeHotness(const Value *V);
111 
112   /// Similar but use value from \p OptDiag and update hotness there.
113   void computeHotness(DiagnosticInfoIROptimization &OptDiag);
114 
115   /// Only allow verbose messages if we know we're filtering by hotness
116   /// (BFI is only set in this case).
shouldEmitVerbose()117   bool shouldEmitVerbose() { return BFI != nullptr; }
118 
119   OptimizationRemarkEmitter(const OptimizationRemarkEmitter &) = delete;
120   void operator=(const OptimizationRemarkEmitter &) = delete;
121 };
122 
123 /// Add a small namespace to avoid name clashes with the classes used in
124 /// the streaming interface.  We want these to be short for better
125 /// write/readability.
126 namespace ore {
127 using NV = DiagnosticInfoOptimizationBase::Argument;
128 using setIsVerbose = DiagnosticInfoOptimizationBase::setIsVerbose;
129 using setExtraArgs = DiagnosticInfoOptimizationBase::setExtraArgs;
130 }
131 
132 /// OptimizationRemarkEmitter legacy analysis pass
133 ///
134 /// Note that this pass shouldn't generally be marked as preserved by other
135 /// passes.  It's holding onto BFI, so if the pass does not preserve BFI, BFI
136 /// could be freed.
137 class OptimizationRemarkEmitterWrapperPass : public FunctionPass {
138   std::unique_ptr<OptimizationRemarkEmitter> ORE;
139 
140 public:
141   OptimizationRemarkEmitterWrapperPass();
142 
143   bool runOnFunction(Function &F) override;
144 
145   void getAnalysisUsage(AnalysisUsage &AU) const override;
146 
getORE()147   OptimizationRemarkEmitter &getORE() {
148     assert(ORE && "pass not run yet");
149     return *ORE;
150   }
151 
152   static char ID;
153 };
154 
155 class OptimizationRemarkEmitterAnalysis
156     : public AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis> {
157   friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>;
158   static AnalysisKey Key;
159 
160 public:
161   /// Provide the result typedef for this analysis pass.
162   typedef OptimizationRemarkEmitter Result;
163 
164   /// Run the analysis pass over a function and produce BFI.
165   Result run(Function &F, FunctionAnalysisManager &AM);
166 };
167 }
168 #endif // LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
169