blob: 6584876f20a7b7c9e8d77f3c5bda4e92c4c3ae32 [file] [log] [blame]
Adam Nemetaad81602016-07-15 17:23:20 +00001//===- OptimizationDiagnosticInfo.cpp - 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#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
Adam Nemet896c09b2016-08-10 00:44:44 +000016#include "llvm/Analysis/BranchProbabilityInfo.h"
Adam Nemetaad81602016-07-15 17:23:20 +000017#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
18#include "llvm/Analysis/LoopInfo.h"
Adam Nemeta62b7e12016-09-27 20:55:07 +000019#include "llvm/IR/DebugInfo.h"
Adam Nemetaad81602016-07-15 17:23:20 +000020#include "llvm/IR/DiagnosticInfo.h"
Adam Nemet896c09b2016-08-10 00:44:44 +000021#include "llvm/IR/Dominators.h"
Adam Nemetaad81602016-07-15 17:23:20 +000022#include "llvm/IR/LLVMContext.h"
23
24using namespace llvm;
25
Adam Nemet896c09b2016-08-10 00:44:44 +000026OptimizationRemarkEmitter::OptimizationRemarkEmitter(Function *F)
27 : F(F), BFI(nullptr) {
28 if (!F->getContext().getDiagnosticHotnessRequested())
29 return;
30
31 // First create a dominator tree.
32 DominatorTree DT;
33 DT.recalculate(*F);
34
35 // Generate LoopInfo from it.
36 LoopInfo LI;
37 LI.analyze(DT);
38
39 // Then compute BranchProbabilityInfo.
40 BranchProbabilityInfo BPI;
41 BPI.calculate(*F, LI);
42
43 // Finally compute BFI.
44 OwnedBFI = llvm::make_unique<BlockFrequencyInfo>(*F, BPI, LI);
45 BFI = OwnedBFI.get();
46}
47
Adam Nemet6100d162016-07-20 21:44:22 +000048Optional<uint64_t> OptimizationRemarkEmitter::computeHotness(const Value *V) {
Adam Nemetaad81602016-07-15 17:23:20 +000049 if (!BFI)
50 return None;
51
52 return BFI->getBlockProfileCount(cast<BasicBlock>(V));
53}
54
Adam Nemeta62b7e12016-09-27 20:55:07 +000055namespace llvm {
56namespace yaml {
57
58template <> struct MappingTraits<DiagnosticInfoOptimizationBase *> {
59 static void mapping(IO &io, DiagnosticInfoOptimizationBase *&OptDiag) {
60 assert(io.outputting() && "input not yet implemented");
61
Adam Nemetc507ac92016-09-27 23:47:03 +000062 if (io.mapTag("!Passed", OptDiag->getKind() == DK_OptimizationRemark))
63 ;
64 else if (io.mapTag("!Missed",
65 OptDiag->getKind() == DK_OptimizationRemarkMissed))
66 ;
67 else if (io.mapTag("!Analysis",
68 OptDiag->getKind() == DK_OptimizationRemarkAnalysis))
Adam Nemeta62b7e12016-09-27 20:55:07 +000069 ;
Adam Nemet2780ee02016-10-04 17:05:01 +000070 else if (io.mapTag("!AnalysisFPCommute",
71 OptDiag->getKind() ==
72 DK_OptimizationRemarkAnalysisFPCommute))
73 ;
74 else if (io.mapTag("!AnalysisAliasing",
75 OptDiag->getKind() ==
76 DK_OptimizationRemarkAnalysisAliasing))
77 ;
Adam Nemeta62b7e12016-09-27 20:55:07 +000078 else
79 llvm_unreachable("todo");
80
81 // These are read-only for now.
82 DebugLoc DL = OptDiag->getDebugLoc();
83 StringRef FN = OptDiag->getFunction().getName();
84
85 StringRef PassName(OptDiag->PassName);
86 io.mapRequired("Pass", PassName);
87 io.mapRequired("Name", OptDiag->RemarkName);
88 if (!io.outputting() || DL)
89 io.mapOptional("DebugLoc", DL);
90 io.mapRequired("Function", FN);
91 io.mapOptional("Hotness", OptDiag->Hotness);
92 io.mapOptional("Args", OptDiag->Args);
93 }
94};
95
96template <> struct MappingTraits<DebugLoc> {
97 static void mapping(IO &io, DebugLoc &DL) {
98 assert(io.outputting() && "input not yet implemented");
99
100 auto *Scope = cast<DIScope>(DL.getScope());
101 StringRef File = Scope->getFilename();
102 unsigned Line = DL.getLine();
103 unsigned Col = DL.getCol();
104
105 io.mapRequired("File", File);
106 io.mapRequired("Line", Line);
107 io.mapRequired("Column", Col);
108 }
109
110 static const bool flow = true;
111};
112
Adam Nemet0428e932016-10-04 17:05:04 +0000113// Implement this as a mapping for now to get proper quotation for the value.
114template <> struct MappingTraits<DiagnosticInfoOptimizationBase::Argument> {
115 static void mapping(IO &io, DiagnosticInfoOptimizationBase::Argument &A) {
116 assert(io.outputting() && "input not yet implemented");
117 io.mapRequired(A.Key.data(), A.Val);
Adam Nemeta62b7e12016-09-27 20:55:07 +0000118 }
Adam Nemeta62b7e12016-09-27 20:55:07 +0000119};
120
121} // end namespace yaml
122} // end namespace llvm
123
124LLVM_YAML_IS_SEQUENCE_VECTOR(DiagnosticInfoOptimizationBase::Argument)
125
126void OptimizationRemarkEmitter::computeHotness(
127 DiagnosticInfoOptimizationBase &OptDiag) {
128 Value *V = OptDiag.getCodeRegion();
129 if (V)
130 OptDiag.setHotness(computeHotness(V));
131}
132
133void OptimizationRemarkEmitter::emit(DiagnosticInfoOptimizationBase &OptDiag) {
134 computeHotness(OptDiag);
135
136 yaml::Output *Out = F->getContext().getDiagnosticsOutputFile();
Hal Finkelbdd67352016-10-04 18:13:45 +0000137 if (Out) {
Adam Nemeta62b7e12016-09-27 20:55:07 +0000138 auto *P = &const_cast<DiagnosticInfoOptimizationBase &>(OptDiag);
139 *Out << P;
140 }
141 // FIXME: now that IsVerbose is part of DI, filtering for this will be moved
142 // from here to clang.
143 if (!OptDiag.isVerbose() || shouldEmitVerbose())
144 F->getContext().diagnose(OptDiag);
145}
146
Adam Nemet7cfd5972016-07-21 01:07:13 +0000147void OptimizationRemarkEmitter::emitOptimizationRemark(const char *PassName,
148 const DebugLoc &DLoc,
149 const Value *V,
150 const Twine &Msg) {
151 LLVMContext &Ctx = F->getContext();
Adam Nemet04758ba2016-09-27 22:19:23 +0000152 Ctx.diagnose(OptimizationRemark(PassName, *F, DLoc, Msg, computeHotness(V)));
Adam Nemet7cfd5972016-07-21 01:07:13 +0000153}
154
155void OptimizationRemarkEmitter::emitOptimizationRemark(const char *PassName,
156 Loop *L,
157 const Twine &Msg) {
158 emitOptimizationRemark(PassName, L->getStartLoc(), L->getHeader(), Msg);
159}
160
Adam Nemetaad81602016-07-15 17:23:20 +0000161void OptimizationRemarkEmitter::emitOptimizationRemarkMissed(
Adam Nemet6100d162016-07-20 21:44:22 +0000162 const char *PassName, const DebugLoc &DLoc, const Value *V,
Adam Nemetcef33142016-08-26 20:21:05 +0000163 const Twine &Msg, bool IsVerbose) {
Adam Nemetaad81602016-07-15 17:23:20 +0000164 LLVMContext &Ctx = F->getContext();
Adam Nemetcef33142016-08-26 20:21:05 +0000165 if (!IsVerbose || shouldEmitVerbose())
Adam Nemet04758ba2016-09-27 22:19:23 +0000166 Ctx.diagnose(
167 OptimizationRemarkMissed(PassName, *F, DLoc, Msg, computeHotness(V)));
Adam Nemetaad81602016-07-15 17:23:20 +0000168}
169
170void OptimizationRemarkEmitter::emitOptimizationRemarkMissed(
Adam Nemetcef33142016-08-26 20:21:05 +0000171 const char *PassName, Loop *L, const Twine &Msg, bool IsVerbose) {
172 emitOptimizationRemarkMissed(PassName, L->getStartLoc(), L->getHeader(), Msg,
173 IsVerbose);
Adam Nemetaad81602016-07-15 17:23:20 +0000174}
175
Adam Nemet5b3a5cf2016-07-20 21:44:26 +0000176void OptimizationRemarkEmitter::emitOptimizationRemarkAnalysis(
177 const char *PassName, const DebugLoc &DLoc, const Value *V,
Adam Nemetcef33142016-08-26 20:21:05 +0000178 const Twine &Msg, bool IsVerbose) {
Adam Nemet5b3a5cf2016-07-20 21:44:26 +0000179 LLVMContext &Ctx = F->getContext();
Adam Nemetcef33142016-08-26 20:21:05 +0000180 if (!IsVerbose || shouldEmitVerbose())
Adam Nemet04758ba2016-09-27 22:19:23 +0000181 Ctx.diagnose(
182 OptimizationRemarkAnalysis(PassName, *F, DLoc, Msg, computeHotness(V)));
Adam Nemet5b3a5cf2016-07-20 21:44:26 +0000183}
184
185void OptimizationRemarkEmitter::emitOptimizationRemarkAnalysis(
Adam Nemetcef33142016-08-26 20:21:05 +0000186 const char *PassName, Loop *L, const Twine &Msg, bool IsVerbose) {
Adam Nemet5b3a5cf2016-07-20 21:44:26 +0000187 emitOptimizationRemarkAnalysis(PassName, L->getStartLoc(), L->getHeader(),
Adam Nemetcef33142016-08-26 20:21:05 +0000188 Msg, IsVerbose);
Adam Nemet5b3a5cf2016-07-20 21:44:26 +0000189}
190
Adam Nemet0e0e2d52016-07-20 23:50:32 +0000191void OptimizationRemarkEmitter::emitOptimizationRemarkAnalysisFPCommute(
Adam Nemetcbe2a9b2016-07-21 01:11:12 +0000192 const char *PassName, const DebugLoc &DLoc, const Value *V,
193 const Twine &Msg) {
Adam Nemet0e0e2d52016-07-20 23:50:32 +0000194 LLVMContext &Ctx = F->getContext();
Adam Nemet04758ba2016-09-27 22:19:23 +0000195 Ctx.diagnose(OptimizationRemarkAnalysisFPCommute(PassName, *F, DLoc, Msg,
196 computeHotness(V)));
Adam Nemet0e0e2d52016-07-20 23:50:32 +0000197}
198
199void OptimizationRemarkEmitter::emitOptimizationRemarkAnalysisAliasing(
Adam Nemetcbe2a9b2016-07-21 01:11:12 +0000200 const char *PassName, const DebugLoc &DLoc, const Value *V,
201 const Twine &Msg) {
Adam Nemet0e0e2d52016-07-20 23:50:32 +0000202 LLVMContext &Ctx = F->getContext();
Adam Nemet04758ba2016-09-27 22:19:23 +0000203 Ctx.diagnose(OptimizationRemarkAnalysisAliasing(PassName, *F, DLoc, Msg,
204 computeHotness(V)));
Adam Nemet0e0e2d52016-07-20 23:50:32 +0000205}
206
207void OptimizationRemarkEmitter::emitOptimizationRemarkAnalysisAliasing(
208 const char *PassName, Loop *L, const Twine &Msg) {
209 emitOptimizationRemarkAnalysisAliasing(PassName, L->getStartLoc(),
210 L->getHeader(), Msg);
211}
212
Adam Nemet79ac42a2016-07-18 16:29:21 +0000213OptimizationRemarkEmitterWrapperPass::OptimizationRemarkEmitterWrapperPass()
214 : FunctionPass(ID) {
215 initializeOptimizationRemarkEmitterWrapperPassPass(
216 *PassRegistry::getPassRegistry());
217}
218
219bool OptimizationRemarkEmitterWrapperPass::runOnFunction(Function &Fn) {
220 BlockFrequencyInfo *BFI;
Adam Nemetaad81602016-07-15 17:23:20 +0000221
222 if (Fn.getContext().getDiagnosticHotnessRequested())
223 BFI = &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI();
224 else
225 BFI = nullptr;
226
Adam Nemet79ac42a2016-07-18 16:29:21 +0000227 ORE = llvm::make_unique<OptimizationRemarkEmitter>(&Fn, BFI);
Adam Nemetaad81602016-07-15 17:23:20 +0000228 return false;
229}
230
Adam Nemet79ac42a2016-07-18 16:29:21 +0000231void OptimizationRemarkEmitterWrapperPass::getAnalysisUsage(
232 AnalysisUsage &AU) const {
Adam Nemetaad81602016-07-15 17:23:20 +0000233 LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU);
234 AU.setPreservesAll();
235}
236
Adam Nemet79ac42a2016-07-18 16:29:21 +0000237char OptimizationRemarkEmitterAnalysis::PassID;
238
239OptimizationRemarkEmitter
Adam Nemet78d10912016-07-20 21:44:18 +0000240OptimizationRemarkEmitterAnalysis::run(Function &F,
Sean Silva36e0d012016-08-09 00:28:15 +0000241 FunctionAnalysisManager &AM) {
Adam Nemet79ac42a2016-07-18 16:29:21 +0000242 BlockFrequencyInfo *BFI;
243
244 if (F.getContext().getDiagnosticHotnessRequested())
245 BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
246 else
247 BFI = nullptr;
248
249 return OptimizationRemarkEmitter(&F, BFI);
250}
251
252char OptimizationRemarkEmitterWrapperPass::ID = 0;
Adam Nemetaad81602016-07-15 17:23:20 +0000253static const char ore_name[] = "Optimization Remark Emitter";
254#define ORE_NAME "opt-remark-emitter"
255
Adam Nemet79ac42a2016-07-18 16:29:21 +0000256INITIALIZE_PASS_BEGIN(OptimizationRemarkEmitterWrapperPass, ORE_NAME, ore_name,
257 false, true)
Adam Nemetaad81602016-07-15 17:23:20 +0000258INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)
Adam Nemet79ac42a2016-07-18 16:29:21 +0000259INITIALIZE_PASS_END(OptimizationRemarkEmitterWrapperPass, ORE_NAME, ore_name,
260 false, true)