LLVM  9.0.0svn
MachineOptimizationRemarkEmitter.h
Go to the documentation of this file.
1 ///===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- 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 /// \file
9 /// Optimization diagnostic interfaces for machine passes. It's packaged as an
10 /// analysis pass so that by using this service passes become dependent on MBFI
11 /// as well. MBFI is used to compute the "hotness" of the diagnostic message.
12 ///
13 ///===---------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CODEGEN_MACHINEOPTIMIZATIONREMARKEMITTER_H
16 #define LLVM_CODEGEN_MACHINEOPTIMIZATIONREMARKEMITTER_H
17 
20 
21 namespace llvm {
22 class MachineBasicBlock;
23 class MachineBlockFrequencyInfo;
24 class MachineInstr;
25 
26 /// Common features for diagnostics dealing with optimization remarks
27 /// that are used by machine passes.
29 public:
32  const DiagnosticLocation &Loc,
33  const MachineBasicBlock *MBB)
34  : DiagnosticInfoOptimizationBase(Kind, DS_Remark, PassName, RemarkName,
35  MBB->getParent()->getFunction(), Loc),
36  MBB(MBB) {}
37 
38  /// MI-specific kinds of diagnostic Arguments.
40  /// Print an entire MachineInstr.
42  };
43 
44  static bool classof(const DiagnosticInfo *DI) {
45  return DI->getKind() >= DK_FirstMachineRemark &&
47  }
48 
49  const MachineBasicBlock *getBlock() const { return MBB; }
50 
51 private:
52  const MachineBasicBlock *MBB;
53 };
54 
55 /// Diagnostic information for applied optimization remarks.
57 public:
58  /// \p PassName is the name of the pass emitting this diagnostic. If this name
59  /// matches the regular expression given in -Rpass=, then the diagnostic will
60  /// be emitted. \p RemarkName is a textual identifier for the remark. \p
61  /// Loc is the debug location and \p MBB is the block that the optimization
62  /// operates in.
64  const DiagnosticLocation &Loc,
65  const MachineBasicBlock *MBB)
67  RemarkName, Loc, MBB) {}
68 
69  static bool classof(const DiagnosticInfo *DI) {
70  return DI->getKind() == DK_MachineOptimizationRemark;
71  }
72 
73  /// \see DiagnosticInfoOptimizationBase::isEnabled.
74  bool isEnabled() const override {
75  const Function &Fn = getFunction();
76  LLVMContext &Ctx = Fn.getContext();
78  }
79 };
80 
81 /// Diagnostic information for missed-optimization remarks.
83 public:
84  /// \p PassName is the name of the pass emitting this diagnostic. If this name
85  /// matches the regular expression given in -Rpass-missed=, then the
86  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
87  /// remark. \p Loc is the debug location and \p MBB is the block that the
88  /// optimization operates in.
90  const DiagnosticLocation &Loc,
91  const MachineBasicBlock *MBB)
93  PassName, RemarkName, Loc, MBB) {}
94 
95  static bool classof(const DiagnosticInfo *DI) {
97  }
98 
99  /// \see DiagnosticInfoOptimizationBase::isEnabled.
100  bool isEnabled() const override {
101  const Function &Fn = getFunction();
102  LLVMContext &Ctx = Fn.getContext();
104  }
105 };
106 
107 /// Diagnostic information for optimization analysis remarks.
109 public:
110  /// \p PassName is the name of the pass emitting this diagnostic. If this name
111  /// matches the regular expression given in -Rpass-analysis=, then the
112  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
113  /// remark. \p Loc is the debug location and \p MBB is the block that the
114  /// optimization operates in.
116  const DiagnosticLocation &Loc,
117  const MachineBasicBlock *MBB)
119  PassName, RemarkName, Loc, MBB) {}
120 
121  static bool classof(const DiagnosticInfo *DI) {
123  }
124 
125  /// \see DiagnosticInfoOptimizationBase::isEnabled.
126  bool isEnabled() const override {
127  const Function &Fn = getFunction();
128  LLVMContext &Ctx = Fn.getContext();
130  }
131 };
132 
133 /// Extend llvm::ore:: with MI-specific helper names.
134 namespace ore {
136 }
137 
138 /// The optimization diagnostic interface.
139 ///
140 /// It allows reporting when optimizations are performed and when they are not
141 /// along with the reasons for it. Hotness information of the corresponding
142 /// code region can be included in the remark if DiagnosticsHotnessRequested is
143 /// enabled in the LLVM context.
145 public:
148  : MF(MF), MBFI(MBFI) {}
149 
150  /// Emit an optimization remark.
151  void emit(DiagnosticInfoOptimizationBase &OptDiag);
152 
153  /// Whether we allow for extra compile-time budget to perform more
154  /// analysis to be more informative.
155  ///
156  /// This is useful to enable additional missed optimizations to be reported
157  /// that are normally too noisy. In this mode, we can use the extra analysis
158  /// (1) to filter trivial false positives or (2) to provide more context so
159  /// that non-trivial false positives can be quickly detected by the user.
161  return (
162  MF.getFunction().getContext().getRemarkStreamer() ||
163  MF.getFunction().getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(
164  PassName));
165  }
166 
167  /// Take a lambda that returns a remark which will be emitted. Second
168  /// argument is only used to restrict this to functions.
169  template <typename T>
170  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
171  // Avoid building the remark unless we know there are at least *some*
172  // remarks enabled. We can't currently check whether remarks are requested
173  // for the calling pass since that requires actually building the remark.
174 
175  if (MF.getFunction().getContext().getRemarkStreamer() ||
176  MF.getFunction()
177  .getContext()
178  .getDiagHandlerPtr()
179  ->isAnyRemarkEnabled()) {
180  auto R = RemarkBuilder();
182  }
183  }
184 
185 private:
186  MachineFunction &MF;
187 
188  /// MBFI is only set if hotness is requested.
190 
191  /// Compute hotness from IR value (currently assumed to be a block) if PGO is
192  /// available.
193  Optional<uint64_t> computeHotness(const MachineBasicBlock &MBB);
194 
195  /// Similar but use value from \p OptDiag and update hotness there.
196  void computeHotness(DiagnosticInfoMIROptimization &Remark);
197 
198  /// Only allow verbose messages if we know we're filtering by hotness
199  /// (BFI is only set in this case).
200  bool shouldEmitVerbose() { return MBFI != nullptr; }
201 };
202 
203 /// The analysis pass
204 ///
205 /// Note that this pass shouldn't generally be marked as preserved by other
206 /// passes. It's holding onto BFI, so if the pass does not preserve BFI, BFI
207 /// could be freed.
209  std::unique_ptr<MachineOptimizationRemarkEmitter> ORE;
210 
211 public:
213 
214  bool runOnMachineFunction(MachineFunction &MF) override;
215 
216  void getAnalysisUsage(AnalysisUsage &AU) const override;
217 
219  assert(ORE && "pass not run yet");
220  return *ORE;
221  }
222 
223  static char ID;
224 };
225 }
226 
227 #endif
const char * PassName
Name of the pass that triggers this report.
DiagnosticKind
Defines the different supported kind of a diagnostic.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MachineOptimizationRemarkEmitter(MachineFunction &MF, MachineBlockFrequencyInfo *MBFI)
Diagnostic information for applied optimization remarks.
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
DiagnosticInfoMIROptimization(enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
Diagnostic information for optimization analysis remarks.
static bool classof(const DiagnosticInfo *DI)
bool allowExtraAnalysis(StringRef PassName) const
Whether we allow for extra compile-time budget to perform more analysis to be more informative...
StringRef RemarkName
Textual identifier for the remark (single-word, camel-case).
static bool classof(const DiagnosticInfo *DI)
MachineArgument(StringRef Key, const MachineInstr &MI)
Print an entire MachineInstr.
This is the base abstract class for diagnostic reporting in the backend.
const Function & getFunction() const
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Represent the analysis usage information of a pass.
MachineOptimizationRemarkMissed(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:192
Used in the streaming interface as the general argument type.
virtual bool isMissedOptRemarkEnabled(StringRef PassName) const
Return true if missed optimization remarks are enabled, override to provide different implementation...
MachineOptimizationRemark(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
Common features for diagnostics dealing with optimization remarks that are used by both IR and MIR pa...
The optimization diagnostic interface.
void emit(T RemarkBuilder, decltype(RemarkBuilder()) *=nullptr)
Take a lambda that returns a remark which will be emitted.
virtual bool isPassedOptRemarkEnabled(StringRef PassName) const
Return true if passed optimization remarks are enabled, override to provide different implementation...
Representation of each machine instruction.
Definition: MachineInstr.h:63
virtual bool isAnalysisRemarkEnabled(StringRef PassName) const
Return true if analysis remarks are enabled, override to provide different implementation.
Diagnostic information for missed-optimization remarks.
MachineOptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
const DiagnosticHandler * getDiagHandlerPtr() const
getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by setDiagnosticHandler.
static bool classof(const DiagnosticInfo *DI)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const Function * getParent(const Value *V)
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Common features for diagnostics dealing with optimization remarks that are used by machine passes...