LLVM 19.0.0git
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#include "llvm/IR/Function.h"
21#include <optional>
22
23namespace llvm {
24class MachineBasicBlock;
25class MachineBlockFrequencyInfo;
26class MachineInstr;
27
28/// Common features for diagnostics dealing with optimization remarks
29/// that are used by machine passes.
31public:
34 const DiagnosticLocation &Loc,
35 const MachineBasicBlock *MBB)
37 MBB->getParent()->getFunction(), Loc),
38 MBB(MBB) {}
39
40 /// MI-specific kinds of diagnostic Arguments.
42 /// Print an entire MachineInstr.
44 };
45
46 static bool classof(const DiagnosticInfo *DI) {
47 return DI->getKind() >= DK_FirstMachineRemark &&
49 }
50
51 const MachineBasicBlock *getBlock() const { return MBB; }
52
53private:
54 const MachineBasicBlock *MBB;
55};
56
57/// Diagnostic information for applied optimization remarks.
59public:
60 /// \p PassName is the name of the pass emitting this diagnostic. If this name
61 /// matches the regular expression given in -Rpass=, then the diagnostic will
62 /// be emitted. \p RemarkName is a textual identifier for the remark. \p
63 /// Loc is the debug location and \p MBB is the block that the optimization
64 /// operates in.
66 const DiagnosticLocation &Loc,
67 const MachineBasicBlock *MBB)
69 RemarkName, Loc, MBB) {}
70
71 static bool classof(const DiagnosticInfo *DI) {
73 }
74
75 /// \see DiagnosticInfoOptimizationBase::isEnabled.
76 bool isEnabled() const override {
77 const Function &Fn = getFunction();
78 LLVMContext &Ctx = Fn.getContext();
80 }
81};
82
83/// Diagnostic information for missed-optimization remarks.
85public:
86 /// \p PassName is the name of the pass emitting this diagnostic. If this name
87 /// matches the regular expression given in -Rpass-missed=, then the
88 /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
89 /// remark. \p Loc is the debug location and \p MBB is the block that the
90 /// optimization operates in.
92 const DiagnosticLocation &Loc,
93 const MachineBasicBlock *MBB)
95 PassName, RemarkName, Loc, MBB) {}
96
97 static bool classof(const DiagnosticInfo *DI) {
99 }
100
101 /// \see DiagnosticInfoOptimizationBase::isEnabled.
102 bool isEnabled() const override {
103 const Function &Fn = getFunction();
104 LLVMContext &Ctx = Fn.getContext();
106 }
107};
108
109/// Diagnostic information for optimization analysis remarks.
111public:
112 /// \p PassName is the name of the pass emitting this diagnostic. If this name
113 /// matches the regular expression given in -Rpass-analysis=, then the
114 /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
115 /// remark. \p Loc is the debug location and \p MBB is the block that the
116 /// optimization operates in.
118 const DiagnosticLocation &Loc,
119 const MachineBasicBlock *MBB)
121 PassName, RemarkName, Loc, MBB) {}
122
124 const MachineInstr *MI)
127 MI->getParent()) {}
128
129 static bool classof(const DiagnosticInfo *DI) {
131 }
132
133 /// \see DiagnosticInfoOptimizationBase::isEnabled.
134 bool isEnabled() const override {
135 const Function &Fn = getFunction();
136 LLVMContext &Ctx = Fn.getContext();
138 }
139};
140
141/// Extend llvm::ore:: with MI-specific helper names.
142namespace ore {
144}
145
146/// The optimization diagnostic interface.
147///
148/// It allows reporting when optimizations are performed and when they are not
149/// along with the reasons for it. Hotness information of the corresponding
150/// code region can be included in the remark if DiagnosticsHotnessRequested is
151/// enabled in the LLVM context.
153public:
156 : MF(MF), MBFI(MBFI) {}
157
158 /// Emit an optimization remark.
160
161 /// Whether we allow for extra compile-time budget to perform more
162 /// analysis to be more informative.
163 ///
164 /// This is useful to enable additional missed optimizations to be reported
165 /// that are normally too noisy. In this mode, we can use the extra analysis
166 /// (1) to filter trivial false positives or (2) to provide more context so
167 /// that non-trivial false positives can be quickly detected by the user.
169 return (
172 PassName));
173 }
174
175 /// Take a lambda that returns a remark which will be emitted. Second
176 /// argument is only used to restrict this to functions.
177 template <typename T>
178 void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
179 // Avoid building the remark unless we know there are at least *some*
180 // remarks enabled. We can't currently check whether remarks are requested
181 // for the calling pass since that requires actually building the remark.
182
184 MF.getFunction()
185 .getContext()
187 ->isAnyRemarkEnabled()) {
188 auto R = RemarkBuilder();
190 }
191 }
192
194 return MBFI;
195 }
196
197private:
198 MachineFunction &MF;
199
200 /// MBFI is only set if hotness is requested.
202
203 /// Compute hotness from IR value (currently assumed to be a block) if PGO is
204 /// available.
205 std::optional<uint64_t> computeHotness(const MachineBasicBlock &MBB);
206
207 /// Similar but use value from \p OptDiag and update hotness there.
208 void computeHotness(DiagnosticInfoMIROptimization &Remark);
209
210 /// Only allow verbose messages if we know we're filtering by hotness
211 /// (BFI is only set in this case).
212 bool shouldEmitVerbose() { return MBFI != nullptr; }
213};
214
215/// The analysis pass
216///
217/// Note that this pass shouldn't generally be marked as preserved by other
218/// passes. It's holding onto BFI, so if the pass does not preserve BFI, BFI
219/// could be freed.
221 std::unique_ptr<MachineOptimizationRemarkEmitter> ORE;
222
223public:
225
226 bool runOnMachineFunction(MachineFunction &MF) override;
227
228 void getAnalysisUsage(AnalysisUsage &AU) const override;
229
231 assert(ORE && "pass not run yet");
232 return *ORE;
233 }
234
235 static char ID;
236};
237}
238
239#endif
MachineBasicBlock & MBB
static const Function * getParent(const Value *V)
dxil metadata emit
IRTranslator LLVM IR MI
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char PassName[]
Represent the analysis usage information of a pass.
Common features for diagnostics dealing with optimization remarks that are used by machine passes.
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoMIROptimization(enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
Common features for diagnostics dealing with optimization remarks that are used by both IR and MIR pa...
const char * PassName
Name of the pass that triggers this report.
StringRef RemarkName
Textual identifier for the remark (single-word, camel-case).
const Function & getFunction() const
This is the base abstract class for diagnostic reporting in the backend.
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:342
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
const DiagnosticHandler * getDiagHandlerPtr() const
getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by setDiagnosticHandler.
LLVMRemarkStreamer * getLLVMRemarkStreamer()
The "LLVM remark streamer" used by LLVM to serialize remark diagnostics comming from IR and MIR passe...
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
Definition: MachineInstr.h:69
Diagnostic information for optimization analysis remarks.
MachineOptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName, const MachineInstr *MI)
MachineOptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
void emit(T RemarkBuilder, decltype(RemarkBuilder()) *=nullptr)
Take a lambda that returns a remark which will be emitted.
bool allowExtraAnalysis(StringRef PassName) const
Whether we allow for extra compile-time budget to perform more analysis to be more informative.
MachineOptimizationRemarkEmitter(MachineFunction &MF, MachineBlockFrequencyInfo *MBFI)
Diagnostic information for missed-optimization remarks.
static bool classof(const DiagnosticInfo *DI)
MachineOptimizationRemarkMissed(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
Diagnostic information for applied optimization remarks.
static bool classof(const DiagnosticInfo *DI)
MachineOptimizationRemark(const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const MachineBasicBlock *MBB)
PassName is the name of the pass emitting this diagnostic.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
DiagnosticKind
Defines the different supported kind of a diagnostic.
@ DK_LastMachineRemark
@ DK_MachineOptimizationRemark
@ DK_MachineOptimizationRemarkAnalysis
@ DK_FirstMachineRemark
@ DK_MachineOptimizationRemarkMissed
@ DS_Remark
virtual bool isPassedOptRemarkEnabled(StringRef PassName) const
Return true if passed optimization remarks are enabled, override to provide different implementation.
virtual bool isAnalysisRemarkEnabled(StringRef PassName) const
Return true if analysis remarks are enabled, override to provide different implementation.
virtual bool isMissedOptRemarkEnabled(StringRef PassName) const
Return true if missed optimization remarks are enabled, override to provide different implementation.
bool isAnyRemarkEnabled(StringRef PassName) const
Return true if any type of remarks are enabled for this pass.
Used in the streaming interface as the general argument type.