1 //===- llvm/IR/LLVMRemarkStreamer.cpp - Remark Streamer -*- 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 // This file contains the implementation of the conversion between IR
10 // Diagnostics and serializable remarks::Remark objects.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/IR/LLVMRemarkStreamer.h"
15 #include "llvm/IR/DiagnosticInfo.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/GlobalValue.h"
18 #include "llvm/Support/FileSystem.h"
19
20 using namespace llvm;
21
22 /// DiagnosticKind -> remarks::Type
toRemarkType(enum DiagnosticKind Kind)23 static remarks::Type toRemarkType(enum DiagnosticKind Kind) {
24 switch (Kind) {
25 default:
26 return remarks::Type::Unknown;
27 case DK_OptimizationRemark:
28 case DK_MachineOptimizationRemark:
29 return remarks::Type::Passed;
30 case DK_OptimizationRemarkMissed:
31 case DK_MachineOptimizationRemarkMissed:
32 return remarks::Type::Missed;
33 case DK_OptimizationRemarkAnalysis:
34 case DK_MachineOptimizationRemarkAnalysis:
35 return remarks::Type::Analysis;
36 case DK_OptimizationRemarkAnalysisFPCommute:
37 return remarks::Type::AnalysisFPCommute;
38 case DK_OptimizationRemarkAnalysisAliasing:
39 return remarks::Type::AnalysisAliasing;
40 case DK_OptimizationFailure:
41 return remarks::Type::Failure;
42 }
43 }
44
45 /// DiagnosticLocation -> remarks::RemarkLocation.
46 static Optional<remarks::RemarkLocation>
toRemarkLocation(const DiagnosticLocation & DL)47 toRemarkLocation(const DiagnosticLocation &DL) {
48 if (!DL.isValid())
49 return None;
50 StringRef File = DL.getRelativePath();
51 unsigned Line = DL.getLine();
52 unsigned Col = DL.getColumn();
53 return remarks::RemarkLocation{File, Line, Col};
54 }
55
56 /// LLVM Diagnostic -> Remark
57 remarks::Remark
toRemark(const DiagnosticInfoOptimizationBase & Diag) const58 LLVMRemarkStreamer::toRemark(const DiagnosticInfoOptimizationBase &Diag) const {
59 remarks::Remark R; // The result.
60 R.RemarkType = toRemarkType(static_cast<DiagnosticKind>(Diag.getKind()));
61 R.PassName = Diag.getPassName();
62 R.RemarkName = Diag.getRemarkName();
63 R.FunctionName =
64 GlobalValue::dropLLVMManglingEscape(Diag.getFunction().getName());
65 R.Loc = toRemarkLocation(Diag.getLocation());
66 R.Hotness = Diag.getHotness();
67
68 for (const DiagnosticInfoOptimizationBase::Argument &Arg : Diag.getArgs()) {
69 R.Args.emplace_back();
70 R.Args.back().Key = Arg.Key;
71 R.Args.back().Val = Arg.Val;
72 R.Args.back().Loc = toRemarkLocation(Arg.Loc);
73 }
74
75 return R;
76 }
77
emit(const DiagnosticInfoOptimizationBase & Diag)78 void LLVMRemarkStreamer::emit(const DiagnosticInfoOptimizationBase &Diag) {
79 if (!RS.matchesFilter(Diag.getPassName()))
80 return;
81
82 // First, convert the diagnostic to a remark.
83 remarks::Remark R = toRemark(Diag);
84 // Then, emit the remark through the serializer.
85 RS.getSerializer().emit(R);
86 }
87
88 char LLVMRemarkSetupFileError::ID = 0;
89 char LLVMRemarkSetupPatternError::ID = 0;
90 char LLVMRemarkSetupFormatError::ID = 0;
91
setupLLVMOptimizationRemarks(LLVMContext & Context,StringRef RemarksFilename,StringRef RemarksPasses,StringRef RemarksFormat,bool RemarksWithHotness,Optional<uint64_t> RemarksHotnessThreshold)92 Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks(
93 LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses,
94 StringRef RemarksFormat, bool RemarksWithHotness,
95 Optional<uint64_t> RemarksHotnessThreshold) {
96 if (RemarksWithHotness)
97 Context.setDiagnosticsHotnessRequested(true);
98
99 Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold);
100
101 if (RemarksFilename.empty())
102 return nullptr;
103
104 Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat);
105 if (Error E = Format.takeError())
106 return make_error<LLVMRemarkSetupFormatError>(std::move(E));
107
108 std::error_code EC;
109 auto Flags = *Format == remarks::Format::YAML ? sys::fs::OF_TextWithCRLF
110 : sys::fs::OF_None;
111 auto RemarksFile =
112 std::make_unique<ToolOutputFile>(RemarksFilename, EC, Flags);
113 // We don't use llvm::FileError here because some diagnostics want the file
114 // name separately.
115 if (EC)
116 return make_error<LLVMRemarkSetupFileError>(errorCodeToError(EC));
117
118 Expected<std::unique_ptr<remarks::RemarkSerializer>> RemarkSerializer =
119 remarks::createRemarkSerializer(
120 *Format, remarks::SerializerMode::Separate, RemarksFile->os());
121 if (Error E = RemarkSerializer.takeError())
122 return make_error<LLVMRemarkSetupFormatError>(std::move(E));
123
124 // Create the main remark streamer.
125 Context.setMainRemarkStreamer(std::make_unique<remarks::RemarkStreamer>(
126 std::move(*RemarkSerializer), RemarksFilename));
127
128 // Create LLVM's optimization remarks streamer.
129 Context.setLLVMRemarkStreamer(
130 std::make_unique<LLVMRemarkStreamer>(*Context.getMainRemarkStreamer()));
131
132 if (!RemarksPasses.empty())
133 if (Error E = Context.getMainRemarkStreamer()->setFilter(RemarksPasses))
134 return make_error<LLVMRemarkSetupPatternError>(std::move(E));
135
136 return std::move(RemarksFile);
137 }
138
setupLLVMOptimizationRemarks(LLVMContext & Context,raw_ostream & OS,StringRef RemarksPasses,StringRef RemarksFormat,bool RemarksWithHotness,Optional<uint64_t> RemarksHotnessThreshold)139 Error llvm::setupLLVMOptimizationRemarks(
140 LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses,
141 StringRef RemarksFormat, bool RemarksWithHotness,
142 Optional<uint64_t> RemarksHotnessThreshold) {
143 if (RemarksWithHotness)
144 Context.setDiagnosticsHotnessRequested(true);
145
146 Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold);
147
148 Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat);
149 if (Error E = Format.takeError())
150 return make_error<LLVMRemarkSetupFormatError>(std::move(E));
151
152 Expected<std::unique_ptr<remarks::RemarkSerializer>> RemarkSerializer =
153 remarks::createRemarkSerializer(*Format,
154 remarks::SerializerMode::Separate, OS);
155 if (Error E = RemarkSerializer.takeError())
156 return make_error<LLVMRemarkSetupFormatError>(std::move(E));
157
158 // Create the main remark streamer.
159 Context.setMainRemarkStreamer(
160 std::make_unique<remarks::RemarkStreamer>(std::move(*RemarkSerializer)));
161
162 // Create LLVM's optimization remarks streamer.
163 Context.setLLVMRemarkStreamer(
164 std::make_unique<LLVMRemarkStreamer>(*Context.getMainRemarkStreamer()));
165
166 if (!RemarksPasses.empty())
167 if (Error E = Context.getMainRemarkStreamer()->setFilter(RemarksPasses))
168 return make_error<LLVMRemarkSetupPatternError>(std::move(E));
169
170 return Error::success();
171 }
172